diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..d1579c6 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,4 @@ +# Scripts run by Git Bash need LF line endings, also in a checkout on Windows. +*.sh text eol=lf +*.bat text eol=crlf +*.cmd text eol=crlf diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml new file mode 100644 index 0000000..a845855 --- /dev/null +++ b/.github/FUNDING.yml @@ -0,0 +1 @@ +custom: ["https://buy.stripe.com/6oU4gB5450PZ18h8aK1wY00"] diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..34b3343 --- /dev/null +++ b/.gitignore @@ -0,0 +1,44 @@ +# Only what is listed here is part of the repository. Everything else at the top level stays +# out: the game and anything made from it (extracted files, saves, logs, screenshots, render +# target and audio dumps), build output, downloaded toolchains and other people's packages. +/* +!/.gitignore +!/.gitattributes +!/.gitmodules +!/.github/ +!/README.md +!/README-QUEST-VR.md +!/README-PC-VR.md +!/LICENSE +!/THIRD-PARTY-NOTICES.md +!/Play Astro Bot VR.bat +!/quest-host/ +!/shadps4-arm64-main/ + +# The PC play folder: only the launcher and its settings, not the emulator built into it, nor +# its user folder (saves, logs, shader cache). +!/pc-vr/ +/pc-vr/* +!/pc-vr/launch.ps1 +!/pc-vr/settings.txt + +# Scripts yes, toolchains and downloads no (clang, CMake, Ninja, Windows SDK, sysroot, jadx, +# apktool, PkgTool, the OpenXR loader for Android: see README.md, "Building"). +!/tools/ +/tools/*/ +!/tools/probes/ +!/tools/re/ +!/tools/shims/ +!/tools/tests/ +/tools/*.local + +# Never anywhere: game files and packages. +*.pkg +*.apk +*.sfo +*.sprx +*.prx +eboot.bin +sce_sys/ +sce_module/ +savedata/ diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..d159169 --- /dev/null +++ b/LICENSE @@ -0,0 +1,339 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Lesser General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along + with this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. diff --git a/Play Astro Bot VR.bat b/Play Astro Bot VR.bat new file mode 100644 index 0000000..4832c02 --- /dev/null +++ b/Play Astro Bot VR.bat @@ -0,0 +1,5 @@ +@echo off +rem ASTRO BOT Rescue Mission on this PC, shown in a headset connected through Virtual Desktop +rem (or any other OpenXR runtime). Settings: pc-vr\settings.txt +title Astro Bot VR +powershell -NoProfile -ExecutionPolicy Bypass -File "%~dp0pc-vr\launch.ps1" %* diff --git a/README-PC-VR.md b/README-PC-VR.md new file mode 100644 index 0000000..2299cd3 --- /dev/null +++ b/README-PC-VR.md @@ -0,0 +1,371 @@ +# Astro Bot Rescue Mission on the PC, shown in the headset through Virtual Desktop + +The second way to play (the first, the app that runs on the headset itself, is in +`README-QUEST-VR.md`): the emulator runs on this PC, and the picture goes to the Quest 3 the +way any PC VR game does, through Virtual Desktop. The PC has far more to give than the +headset: the game runs at the console's own 60 frames a second with the console's +multisampling, and draws far larger than the console ever did: 2880x3072 an eye by default, +four times the pixels of its largest size (1440x1536, what a PlayStation 4 Pro uses), chosen +in a small window at every start. + +## Playing + +1. **The controller goes to the PC**, not to the headset: a USB-C cable, or Bluetooth (hold + Create and the PS button until the light bar flashes, then add the device in Windows' + Bluetooth settings). A DualSense remembers one partner: after playing on the headset's own + app it has to be paired with the PC again, and the other way round. Connected to the PC it + gives everything the game uses: buttons, sticks, touchpad, motion sensors, rumble, light bar. + **Paired with the headset instead, it does not work properly**: Virtual Desktop then hands + the PC a copy of it, a plain DualShock 4 without motion sensors and without touchpad - the + controller in the game neither turns nor follows you, and the end of a level (swiping Astro + out of the controller) cannot be done. That is what happened in the first session on + 2026-10-02 (the log says "PS4 Controller"; the console window now warns about it). + **Without a gamepad on the PC the headset's own controllers play** (see below). +2. **Virtual Desktop Streamer** has to be running on the PC (the launcher starts it if it is + not), with its own OpenXR runtime, VDXR, as the PC's OpenXR runtime (Streamer window, + Options). It is, on this PC. +3. In the headset, start **Virtual Desktop** and connect to the PC. In its Streaming settings + the frame rate to pick is **120**: the game then draws 60 frames a second and each is + shown for two refreshes, as on a PlayStation VR. (At 90 it draws 45, at 72 36: see "Speed".) +4. On the desktop you now see in the headset, start **`Play Astro Bot VR.bat`** (in this + folder). A small window comes up first: the **resolution** of each eye (a slider, from the + console's 1440x1536 up to 3600x3840), the **most frames a second**, and the **field of + view**; Play starts the game with them (they are kept in `pc-vr\settings.txt`; untick "Show + this window at every start" to go without it). A console window then says what is found + and what happens; the game's window opens behind it and shows both eyes' pictures side by + side, and after a few seconds the headset switches from the desktop to the game. +5. Pick up the controller. Where it is in the game comes from your hands: put the headset's + own controllers aside (hand tracking on in the headset) and the headset sees your hands + around the gamepad. Virtual Desktop has to pass hand tracking on to the PC (its setting for + forwarding tracking data); where it does not, the emulator takes the places Virtual + Desktop gives the Touch controllers it makes up from the hands while the real ones lie + unused. With neither, the controller floats at a fixed spot in front of you and only turns + with the gamepad's motion sensors. The console window says which it is ("The gamepad is + placed in the game by where the hands are, which ..."). + +The other order works too: start the game at the PC and put the headset on afterwards. The +game waits up to a minute for the headset (`wait` in the settings) and starts in it; after +that it starts on the monitor and moves to the headset whenever Virtual Desktop connects. + +In the game: + +- The first screen asks to move the controller into a floating outline. Hold the controller + up in front of you, where the outline is. (A gamepad without hand tracking is assumed to be + there and the screen passes on its own.) +- The world map is selected by **looking** at a planet and pressing ✕. +- **Resetting the view**: hold OPTIONS for a second (as on a PlayStation VR), or press the PS + button. Where your head is then is where you sit as far as the game goes, and the way you + face is straight ahead. The emulator does it by itself when ✕ is pressed for the first time + after the headset came up, and when the headset's own "reset view" is used (hold the Meta + button). +- A controller without a touchpad (an Xbox pad): the right stick stands in for the finger + (flick it), and the Back / View button for the click. The right stick does that with a + DualSense as well while nothing touches its pad; the game has no other use for it. +- **Taking the headset off pauses the game**, the way the console does it: the picture goes + black and the game waits; it goes on where it was when the headset is back on. The same + happens while Virtual Desktop shows the PC's desktop instead of the game, and when the + connection to the headset breaks: the game waits, and goes on when it is shown again. + (If it ever waits although the headset is on and shows the game: `pause=0`.) +- To quit, close the game's window (or the console window). + +### With the headset's own controllers + +While no gamepad is connected to the PC, the two Touch controllers are the gamepad: + +| Touch controller | DualShock 4 | +| --- | --- | +| left stick | left stick (move) | +| A (right hand) | ✕ (jump, confirm) | +| B (right hand) | □ (punch) | +| X (left hand) | ○ (back) | +| Y (left hand) | △ | +| right stick | the finger on the touchpad: push it the way you would swipe | +| right stick pressed in | the touchpad pressed | +| triggers | L2, R2 | +| grips | L1, R1 | +| menu button (left hand) | OPTIONS | +| left stick pressed in | L3 | +| both sticks pressed in | resets the view | + +**The right controller is the controller in the game**: where it is and where it points is +where the game's DualShock is, tracked fully (a gamepad only gives its turning, and its +place as far as hand tracking sees the hands around it). At the first screen, hold the right +controller into the outline; gadgets shoot where it points. `controller_hand=left` in the +settings makes it the left one. The game's rumble goes to both controllers. A gamepad that +is connected to the PC takes over at once, and gives the controllers back when it goes. + +## Settings + +`pc-vr\settings.txt`, one `key=value` a line (the file explains each): + +| Setting | Meaning | +| --- | --- | +| `resolution=2880` | the width of each eye's picture: `1440` (the console's largest), `1800`, `2160`, `2520`, `2880` (default), `3240`, `3600`; or `game` for the console's sizes chosen by the game. The game draws a step smaller by itself while the graphics card falls behind | +| `dynamic=0` | hold the game to the chosen size even where the graphics card falls behind | +| `fps=60` | the most frames a second: `120`, `90`, `72`, `60` (default), `45`, `40`, `36`, `30`; what the headset's refresh rate allows (see "Speed") | +| `fov=100` | how much of the headset's field of view the game draws, 70 to 100 percent: 100 fills all of it; less puts the same pixels over fewer degrees, sharper, with a dark border | +| `fov_of=psvr` | `fov` is a percent of a PlayStation VR's field of view (100 by 103 degrees an eye, what the game was made for) instead of the headset's own (`fov_of=headset`, the default) | +| `menu=0` | no window with the main settings at the start | +| `sharpen=0.3` | sharpening of the picture on its way out, 0 to 1. Virtual Desktop has its own on top | +| `msaa=4` | the most samples a pixel gets; default as the console draws it. With `1` the emulator smooths edges itself (unless `antialias=0`) | +| `hands=0` | do not use hand tracking to place the controller | +| `predict_ms=20` | how far beyond the next picture the head position given to the game is predicted (0 to 80 ms) | +| `stick_touchpad=0` | the right stick no longer doubles as a finger on the touchpad | +| `controllers=0` | the headset's own controllers never stand in for a gamepad | +| `controller_hand=left` | which Touch controller is the controller in the game (default `right`) | +| `pause=0` | the game is never made to wait when the headset is off the head or shows something else | +| `surround=0` | fold the game's surround sound down instead of rendering it for the headset's speakers | +| `real_time=0` | let the game count time in frames, as on the console | +| `pace=1` | the older way of saying `fps`: refreshes of the headset a frame is given (takes the place of `fps` when set) | +| `wait=60` | seconds to wait for a headset before starting on the monitor (`0`: start at once, move over when it connects) | +| `headset=0` | do not look for a headset, play on the monitor | +| `game=...` | where the game's `eboot.bin` is, if not in `games\CUSA12392` | +| `env=NAME=value` | extra environment variable for the emulator | + +The emulator's own settings (window size, input bindings, log) are in `pc-vr\user\config.json` +and `pc-vr\user\input_config\`. Saves are in `pc-vr\user\home\1000\savedata\CUSA12392` and are +the same format as on the headset: `tools/quest-save-to-pc.sh` copies the save of the +headset's app over (headset on the cable; nothing on the headset is changed, and a save the +PC already has is kept next to the new one). + +**Until 2026-10-03 the PC build never read its save**: every start was a new adventure. The +game's thread that looks for system events started before the one that starts the user +service, the emulator handed it the player's login anyway (a console refuses until the service +is started), the game counted the player twice, took them for one who had come back, and kept +the empty save it had in memory instead of reading theirs. Fixed in the emulator; checked with +the headset's save (World 1, levels 1 to 3 done): the title offers CONTINUE and the world map +has the 14 rescued bots. + +## What you get + +| | PlayStation 4 | Quest 3 on its own (app 0.7) | PC through Virtual Desktop | +| --- | --- | --- | --- | +| Frames a second | 60 | 30 in the levels, 45 in light scenes | 60 (at 120 Hz), up to 120 by the setting | +| Scene size per eye | 960x1080 to 1440x1536 | 816x870 to 1200x1280 | up to 2880x3072 (default), 3600x3840 at most | +| Edges | multisampled | smoothed by a filter | multisampled | +| Head movement | 120 Hz, reprojected | 90 Hz, reprojected | the stream's rate, reprojected in the headset | +| Field of view per eye | PlayStation VR's, 100 by 103 degrees | PlayStation VR's (85% of it from app 0.9 on) | the headset's own, all of it (the simulated Quest 3: 94 by 99 degrees) | + +The game is told the field of view of the headset being worn, as the emulator finds it when +the session starts, and draws exactly that: the picture reaches every edge of the view (with a +PlayStation VR's, as on the console, a Quest 3 would show a narrow dark margin far out to the +sides, while degrees beyond its view on the nose side, top and bottom were drawn for nothing). +What the PC cannot change: the picture reaches the headset as a video stream, with the +softness and the delay that brings (Virtual Desktop's own settings decide those: bitrate, +codec, sharpening). + +Measured on this PC (Ryzen 7 9800X3D, RTX 5070 Ti) with a simulated Quest 3 at 120 Hz +standing in for the headset (see "Testing without the headset"): title, prologue, world map +and the first level, its heaviest view included (1800 draws and 8 million vertices a frame), +at 60.0 frames a second with every frame shown for exactly two refreshes, the GPU busy 5 to +15% of the time at 1440x1536. Level 1-4 at 2160x2304 an eye: 60 frames a second, the GPU busy +20%; at 2880x3072: 60, busy 29%. + +**How the larger sizes come about.** The game has a list of sizes it draws its scene at +(816x870 to 1440x1536 an eye) and makes the pictures it hands to the headset 1440x1536; it +sets aside 200 MB for its render targets and 872 MB of graphics memory for everything. With +`resolution` above 1440 the emulator writes larger sizes into the game as it loads (every +size of the list grown by the same factor, the pictures for the headset too, the pools and +the memory they come from), and gives the emulated console that much more memory: the game +then draws everything at that size itself - a sharper picture, not an enlarged one. + +## Speed + +The emulated PlayStation VR refreshes when the real headset's picture is due (the runtime +tells: once for every picture it wants), and the game draws one frame for every two +refreshes, as it does on the console. With Virtual Desktop at 120 Hz that is the console's 60 +frames a second; at 90 Hz it is 45 and at 72 Hz 36, each frame shown for exactly two +refreshes, and the game is given the time its frames really take, so it runs at its proper +speed whatever the rate (see "Speed" in `README-QUEST-VR.md`). Where the runtime only asks +for 60 pictures a second or fewer (a 60 Hz stream, or Virtual Desktop's Synchronous Spacewarp +making up every other picture itself), the game is given one refresh for a frame instead of +two, which keeps it at 60. + +**More than 60 frames a second** (`fps` above 60): the game may draw a frame for every picture of +the headset. A frame takes this PC 9 to 11 ms whatever the scene (it is the emulator's +processor work that takes the time; the graphics card is busy 13% of it), so 72, 80 and +90 Hz are within reach and 120 is not: there the emulator tries once, finds that frames do +not fit, and stays with every other picture (it tries again every ten minutes; a try is a +few seconds of uneven frames). With the simulated headset at 90 Hz the walk through the +first level held 90 frames a second throughout. The same scripted walk, played at 60 and at +90 frames a second (`tools/pc-rate-compare.sh`), does the same things at the same moments: +the game's own time step follows the frame rate. What does not are the few things the game +counts in frames: an animated sign in the level runs half as fast again at 90. That, and +that nothing but the first level was compared, is why it is a setting and not the way +things are: 120 Hz with the game's own 60 frames is what the game was made for. + +**Hitches**: in play the longest wait for a frame is 20 to 25 ms (a frame is 16.7); where +scenes change (the title, the map, a level loading) single waits of 50 to 235 ms happen, six +in the five and a half minutes from the start into the first level. The head's movement +does not wait for them: the picture that is there keeps being turned by the compositor. + +## How it fits together + +``` +PC +└─ shadps4.exe (the emulator, one process) + ├─ the game's x86-64 code, run directly; PSVR, tracker, camera, sound emulated as on the Quest + ├─ Vulkan on the PC's GPU; every frame the two eyes' pictures are put side by side + │ ├─ at full size into an image of the OpenXR host (the headset's picture) + │ └─ scaled into the window (what the monitor shows) + └─ OpenXR host (thread "shadPS4:XrHost", src/core/vr/openxr_host.cpp) + ├─ session with the PC's OpenXR runtime on the emulator's own Vulkan device + ├─ every picture the runtime asks for: head pose, hands and controllers in, the newest + │ frame out as a projection layer with the pose it was drawn for and the PSVR's + │ field of view + └─ the runtime's compositor turns it to where the head is by the time it is shown + └─ Virtual Desktop Streamer ── video ──► Quest 3 (Virtual Desktop app) +``` + +The OpenXR host is to the PC what the Quest app is to the headset, without the process +boundary: no sockets and no shared buffers, the frame is one GPU copy away. The rest of the +emulator does not know which of the two it talks to. + +Things that had to be right, for whoever works on this again: + +- **The Vulkan device has to suit the runtime.** The runtime names the instance and device + extensions it needs and the graphics card the headset hangs off; the emulator adds them + when it makes its device (`vk_platform.cpp`, `vk_instance.cpp`). A headset that connects + after that still works: the extensions the common Windows runtimes need are enabled + whenever a runtime is installed. +- **The queue is shared.** Runtimes submit to the emulator's Vulkan queue when frames begin + and end, when images are acquired and released, and (Virtual Desktop's) when a swapchain's + images are first listed. All of those calls are made under the lock the emulator's own + submissions take (`Scheduler::submit_mutex`). +- **sRGB.** A runtime takes an 8-bit image that is not of an sRGB format for linear light and + shows it too bright. The headset's picture is drawn into an sRGB image (the eye pass + converts back to linear light at its end, `linear_out` in `post_process.frag`) and copied + to the runtime's sRGB image unchanged. +- **Between two frames of the game** the last picture is submitted again with its pose; the + runtime keeps using the image released last. +- **The headset coming off** shows as the session leaving the "focused" state. The emulator + then tells the game what the console tells it (`sceSystemServiceGetStatus`: the system's + own screen is over the game), which is what makes this game pause. (The headset's own + "worn" flag, `hmuMount`, does nothing to it.) While it waits, the game hands over a black + picture of one pixel an eye; the host shows nothing then instead of asking the runtime for + images of that size. +- **A runtime that asks for no pictures** shows something else in the headset: the game is + told to wait, as when the headset is off. +- **A headset that goes away** is not announced by Virtual Desktop's runtime (its source: a + lost headset only makes it stop asking for pictures, for as long as the session lives; + but it also asks for none while it shows the desktop, which passes by itself, and a new + session pulls the headset back into VR). So the host makes a new session when the headset + was put on and no picture has been asked for since, nor is for 3 seconds; when the + headset is off and nothing was asked for for 30 seconds (either less and less often, up + to every 5 minutes, while it changes nothing); or when the session's calls only fail for + 2 seconds. A runtime that does announce a loss is believed at once. The game is paused + from the loss until a new session is asked for pictures with the headset on the head. +- **The headset's controllers** are read through one OpenXR action set bound to the Touch + profile (which is also what Virtual Desktop's runtime offers for every controller), made + with each session, and handed on as the first player's gamepad the way a scripted or + remote gamepad is (`GameController::ApplyRemoteState`); the aim pose of one of them is the + tracked controller (`Runtime::UpdatePad`). +- **Sound** goes to the device the runtime names for the headset (Virtual Desktop has its + own), and the game's 7.1 mix is rendered for two speakers at the ears as on the Quest; the + microphone is the one the runtime names. Both fall back to Windows' default devices. + +## Fixed on 2026-10-03 (afternoon) + +- **The game stopped at start with the DualSense paired to the PC** ("Unhandled Exception + code 0xc0000005 at 0x800c47a21"): two gamepads were there, the DualSense and the Xbox 360 + controller Virtual Desktop makes of the headset's controllers. Each logged in a player of + its own, the game registered both with the PlayStation VR tracker, and the emulator's + tracker refused the second; the game takes that as fatal. Now, with a headset, there is one + player: the best gamepad (a DualSense before anything else) is theirs and the others are + left alone (the console window says "... is not used"); `env=SHADPS4_VR_ONE_PLAYER=0` in the + settings logs in a player for every gamepad again. The emulated tracker also takes up to + four controllers now, as the console's does. +- **Everything in shade too dark** (most visible in level 1-4, where the ground was black): + objects lit by any light probe but a level's first were lit from the wrong cube faces. See + `README-QUEST-VR.md`, "App 0.10". +- **Field of view: 100% is now all that the headset being worn shows**, not a PlayStation + VR's view. The emulator reads the headset's view from the OpenXR runtime when the session + starts (the console window says "The headset shows ... degrees an eye") and tells the game + that, scaled by the `fov` percent. The game asks once, as it starts; should the headset not + have said by then, the emulator waits up to 10 seconds for it, and after that takes what the + headset showed the last time (kept in `pc-vr\user\vr_headset_fov.json`). `fov_of=psvr` in the settings goes back to the + PlayStation VR's view. + +## When something does not work + +The console window shows the emulator's lines about the headset as they come; the whole log +is `pc-vr\user\log\shad_log.txt` (the start before it: `shad_log.prev.txt`). What to look for: + +| Line | Meaning | +| --- | --- | +| `Headset found through VirtualDesktopXR ...` | the runtime has a headset: Virtual Desktop is connected | +| `Waiting up to 60 s for a headset ...` | the runtime has none yet: connect Virtual Desktop | +| `... has no headset connected yet` / `No headset yet` | still none: the game is on the monitor and moves over when there is | +| `Headset session: focused` | pictures are shown and the headset is on the head | +| `The headset is off the head, or shows something else: the game waits` | the game is told to pause, until `The headset is on the head and shows the game` | +| `Frames are shown through 3 images of 2880x1536` | the picture's size and format in the runtime | +| `Headset: the title delivered 60.0 frames a second (20 ms the longest wait for one, 0 waits of more than 50 ms), 60.0 were shown, the headset took 120.0 pictures a second` | every ten seconds: the game's frame rate against the stream's, and how badly it hitched | +| `pictures were shown N degrees from where they were drawn for` | how much the compositor had to turn pictures: a few degrees while the head turns, next to nothing at rest | +| `Hands: both seen N% of the time ... holding the controller N%` | what hand tracking gave | +| `Controller 1 connected: ... (motion sensors yes, touchpad yes, light yes)` | what Windows handed over of the gamepad | +| `No gamepad is connected to the PC: the headset's controllers stand in for it` | the Touch controllers are the gamepad | +| `Controllers: standing in for the gamepad; the right one tracked N% of the time ...` | every ten seconds: where the tracked controller is and what is pressed | +| `The headset is gone: the game waits until it is back` / `... starting over with it` | the session was lost; a new one is made when the headset answers again | +| `The headset is driven by another graphics card ...` | the PC has two; set `Vulkan/gpu_id` in `config.json` or start with the headset connected | + +No picture in the headset although the session is focused: look for `failed:` lines (frame +calls the runtime refused are counted and logged). + +## Testing without the headset + +Virtual Desktop's runtime has no headset to offer unless one is connected, so the OpenXR path +is tested against the **Meta XR Simulator** (installed on this PC), which is a full OpenXR +runtime with a simulated Quest 3 and its controllers. `XR_RUNTIME_JSON` makes one process use +it; the system's runtime stays Virtual Desktop's. + +| Tool | What it does | +| --- | --- | +| `tools/pc-xrsim-test.sh [NAME=value ...]` | runs the PC build against the simulator, log in `build/dev/xrsim//`. `XRSIM_HZ=120` sets the simulated display's rate; `SHADPS4_INPUT_SCRIPT=` as for `run-win.sh` | +| `tools/window-shot.ps1 [ <png>]` | lists windows, or saves a picture of one (the simulator's shows what its headset shows; the game's shows both eyes) | +| `tools/xrsim-keys.ps1 <key>:<ms> ...` | works the simulator's window: `B` is A and X, `N` is B and Y, `Y G H J` the sticks, `I` the sticks pressed in, `Comma` the menu button (hold keys for a second: short presses are not always seen); `Look:<dx>,<dy>` turns the simulated head, `Click:<x>,<y>` clicks | +| `tools/pc-rate-compare.sh <name> "<NAME=value ...>"` | the same scripted level walk at 60 frames a second and with the given settings, a picture every two seconds from each | +| `tools/xr-probe-win` (`build/xr-probe-win/xr_probe_win.exe`) | what a runtime offers: extensions, system, Vulkan requirements | + +Settings for tests: `SHADPS4_XR_HEAD=0` (the head is a script's to move, the host only +shows), `SHADPS4_XR_FREEZE_AFTER=<s>` (no new pictures after that), `SHADPS4_XR_WAIT=<s>`, +`SHADPS4_XR_HIDE_FOR=<s>` (the headset only turns up that long after the start), +`SHADPS4_XR_LOSE_AFTER=<s>` (the session is taken for lost once), +`SHADPS4_XR_UNWANTED=<from>,<to>` (no pictures are asked for between those seconds of the +session), `SHADPS4_VR_FASTEST_PACE=1` (what `pace=1` sets), `SHADPS4_XR_CONTROLLERS=` +`0`/`1` (off by default under an input script), `SHADPS4_XR_PAD_OFFSET=<x>,<y>,<z>` (where +the gamepad is taken to be from the controller, in metres right, up and towards the player), +`SHADPS4_OPENXR=0`; in input scripts `worn=0` / `worn=1` take the headset off and put it on. + +What the simulator runs showed: the session comes up and is focused; pictures arrive at +2880x1536 in an sRGB image and look right in the simulated headset (upright, colours and +brightness as on the monitor, the narrow margin at the outer edge where the PSVR's field of +view ends; since the game draws the headset's own field of view, the simulator's 54/40/50/49 +degrees an eye, the layer it is handed has exactly that one); at 72 Hz the game locks to 36.0 frames a second and at 120 Hz to 60.0, following +a change of rate while running; pictures are shown where the head is at rest (0.0 degrees +off), also after the head was turned and after the seat was reset there; the first press of +✕ resets the seat; closing the window ends the session cleanly; the game's window minimised +changes nothing in the headset. A headset that only turns up 50 seconds into the game is +picked up and shown to; a session lost in the middle of the game pauses it, and the new +session shows it again at 60.0 frames a second; a runtime that asks for no pictures for a +while (as Virtual Desktop's does while it shows the desktop) pauses the game for as long, +without a new session. The simulated Touch +controllers start the game (A), move the stick and the touchpad finger, reset the view (both +sticks), and the right one, held into the outline of the first screen, passes it: the game +draws its DualShock where that controller is. + +What only a session with the headset on can show: Virtual Desktop's own runtime accepting all +of it (its source says it will: it passes pose and field of view of the layer on, offers the +image format that is asked for, takes the extensions it is given and maps every controller +to the Touch profile), the stream itself, hand tracking through Virtual Desktop, which sound +devices it names, and what it does when the headset is taken off or disconnected (the host +is written to its source, not to its behaviour). + +## Building + +```sh +source tools/env-win.sh && cmake --build build/win-x64 --target shadps4 # the emulator +bash tools/make-pc-vr.sh # copy it to pc-vr/ +``` + +The OpenXR loader (Khronos OpenXR-SDK 1.1.63, `externals/openxr-sdk`) is built with the +emulator; `ENABLE_OPENXR` (on for Windows) switches the whole of it. diff --git a/README-QUEST-VR.md b/README-QUEST-VR.md new file mode 100644 index 0000000..49ad836 --- /dev/null +++ b/README-QUEST-VR.md @@ -0,0 +1,606 @@ +# Astro Bot Rescue Mission on Meta Quest 3 — what is in this folder + +This folder holds a work-in-progress port of the `shadps4-arm64` PS4 emulator core to immersive VR +on Meta Quest, built around one game: ASTRO BOT Rescue Mission (CUSA12392). + +| Folder / file | What it is | +| --- | --- | +| `shadps4-arm64-main/` | The emulator core (fork of shadPS4 with a FEX x86-64 CPU backend), with the PSVR emulation and the sound engine added here | +| `quest-host/` | New Quest app: OpenXR presenter + launcher for the core (`com.astrobotquest.vrhost`) | +| `tools/` | Portable toolchain (clang, CMake, Ninja, Windows SDK, Debian arm64 sysroot) and helper scripts | +| `games/CUSA12392/` | The game, extracted from the PKG | +| `build/win-x64/` | Windows x64 build of the core, used to develop and test on this PC | +| `build/arm64/` | The core cross-compiled for the headset (aarch64 Linux/glibc) | +| `build/quest/astro-vr-host.apk` | The app to install on the headset | +| `pc-vr/`, `Play Astro Bot VR.bat` | The other way to play: the emulator runs on this PC and the headset shows it through Virtual Desktop. Everything about it is in `README-PC-VR.md` | + +**App 0.10 (2026-10-03 afternoon): the light.** Everything lit by the game's light probes +other than the first was lit from the wrong faces: a level keeps its probes in one cube-map +array, and AMD hardware takes the layer of a cube array as face + 8 x cube while the +emulator's array has six faces to a cube; the emulator passed the number on unchanged. In +level 1-4 the ground, lit by the third probe, read layers past the last and came out black; +everything else lit by a later probe (rock in shade, the controller, Astro) came out darker +or in the wrong colour - in every level, not only 1-4. Fixed in the shader translator +(`FixCubeCoords`); the canyon of 1-4 now shows its red earth and green plants. + +**App 0.11 (2026-10-03): the first release on GitHub.** On the headset it does what 0.10 +does; it is built from the published source, which by then also had the PC's field-of-view +changes (`README-PC-VR.md`), which the headset app does not use. + +**App 0.8 (2026-10-03)**, after the fourth session (levels 1-1 to 1-3 played, the game stopped +on entering 1-4 twice): + +- **The crash at level 1-4 ("Cliffhanger")**: the level is the first to draw with a geometry + shader fed with a triangle fan, a kind of primitive the emulator's shader compiler had no + case for; it stopped on purpose there (`spirv_emit_context.cpp: NumVertices: Unreachable + code!`, the emulator ends with signal 5). Fans, polygons, line loops and the strips with + adjacency are handled now; 1-4 loads and plays on the PC and in the headset's sandbox with + the player's own save. The controller's vibration just before is the game's: what the game + asks of the motors lasts a second at most once the emulator is gone. +- **Saves**: the game could miss its save at start (the adventure began anew; it happened on + the PC every time, here only by luck of timing): the emulator handed the game the player's + login before the game had started the user service. Fixed; see `README-PC-VR.md`. +- **Head-butting**: the headset's position reaches the game (every ten seconds core.log says + where it has the head: it follows the player's), and from 0.8 the emulator also works out + how fast the head moves where the headset's system does not say, since the game only takes + a push of the head for one above some speed. +- **`fov=`**: a narrower field of view than the PlayStation VR's for a sharper picture (see + the settings below). In 0.8 it defaulted to the console's own, so nothing changed unless + set; **app 0.9 (same day) makes 85% the default**: 18% more pixels to the degree. + +## How it fits together + +``` +Quest 3 +└─ Astro VR Host (Android app, OpenXR) + ├─ shows the stereo frames as a projection layer; the compositor reprojects them to the + │ current head pose every refresh, like PSVR's own reprojection did + ├─ sends the head pose (and lens distance) to the core every display refresh + ├─ maps a Bluetooth DualSense to the DualShock 4 the game expects: buttons, sticks, + │ triggers, touchpad and motion sensors in; rumble and light bar colour out + ├─ places that controller in the game: from the hands the headset sees holding it when it + │ can, otherwise at a fixed spot in front of the player, turned by its motion sensors + ├─ plays the sound (one audio stream per port the game uses) + └─ starts the emulator core as a child process ──► shadps4 (aarch64 Linux, glibc) + ├─ FEX runs the game's x86-64 code + ├─ Turnip (Mesa) Vulkan driver on the Adreno GPU + ├─ emulated PSVR: HMD, tracker, camera, + │ reprojection, social screen + └─ sound: native Ngs2 engine, 3D audio, + 7.1 rendered for the ear speakers +``` + +Frames travel from the core to the app in shared GPU buffers (AHardwareBuffer / dma-buf), poses and +controller data over unix sockets, audio over a third socket. + +## Building + +Everything builds on this Windows PC from Git Bash, no admin rights, WSL or Android Studio project: + +```sh +source tools/env-win.sh && cmake --build build/win-x64 --target shadps4 # PC test build +bash tools/build-arm64.sh # core for the headset +bash quest-host/build.sh # APK +``` + +`quest-host/build.sh` takes the Linux runtime the core needs (glibc, its loader, the Turnip driver) +out of `bachatas4-0.2.4-release.apk`, which therefore has to stay in this folder. + +## Installing and running + +```sh +adb install -r build/quest/astro-vr-host.apk +adb push games/CUSA12392 /data/local/tmp/astro/games/ # 13 GB, a few minutes +``` + +Pair the DualSense with the headset (Settings ▸ Bluetooth; hold Create + PS until the light bar +flashes), then start **Astro VR Host** from the app library (Unknown Sources). A floating panel +reports what the app is doing, and which controller it found, until the game's first frame arrives. +(The headset's own controllers count as gamepads too, and were what the app took for the +controller in the third session: the game then gets buttons and sticks from the DualSense but +neither its motion sensors nor rumble or light bar. From 0.7 on a controller of Sony's make goes +first whenever it shows up, and the controller is the one input actually comes from.) +Put the Touch controllers aside: with them out of the way the headset tracks your hands, which is +what places the DualSense in the game. + +In the game: + +- The first screen asks to move the controller into a floating outline. Hold the DualSense up in + front of you, where the outline is. (If the headset does not see your hands, the controller is + assumed to be there and the screen passes on its own.) +- The world map is selected by **looking** at a planet and pressing ✕. +- Touchpad: the DualSense's own. If the system does not hand it over, the right stick stands in + for the finger (flick it) and Create for the click. +- **Resetting the view**: hold OPTIONS for a second (as on a PlayStation VR), or press the PS + button. Where your head is then is where you sit as far as the game goes, and the way you face + is straight ahead; the controller's heading is taken anew as well. The app does it by itself + when ✕ is pressed for the first time, and when the headset's own "reset view" is used (hold the + Meta button). Do it again whenever you have settled differently and things are too close, too + far or off to a side: the game takes its bearings only when it is told to (see "Where the + player sits"). +- Taking the headset off pauses the game; putting it back on resumes it. +- If the headset's boundary lights up, you are near its edge: besides being in the way, the + boundary costs the GPU time the game needs. A boundary with more room around the seat avoids + it. + +Optional settings go in `/sdcard/Android/data/com.astrobotquest.vrhost/files/vrhost.txt`, one +`key=value` per line: + +| Setting | Meaning | +| --- | --- | +| `refresh_rate=72` | display refresh rate to ask for (72, 80, 90, 120; default 90). It decides which frame rates the game can keep in step with the display: 45 or 30 frames a second at 90 Hz, 36 at 72, 40 at 80, 60, 40 or 30 at 120, see "Speed" | +| `pace=2` | how many refreshes of the display every frame of the game is given. `2` is the game's own way, as up to version 0.6; a larger number holds it to that. Default: the emulator chooses, see "Speed" | +| `resolution=960` | the size the game draws its scene at, per eye: `816` (x870), `960` (x1080), `1200` (x1280), `1440` (x1536), or `game` for the game's own choice. Default: the emulator chooses, as large as the GPU manages at the pace, see "Speed" | +| `antialias=0` | leave edges as jagged as the game draws them without multisampling. Default: the emulator smooths them, see "The picture" | +| `real_time=0` | let the game count time in frames as on the console: slow motion whenever a frame takes longer than 1/60 s. Default: the emulator has it run by the clock, see "Speed" | +| `hands=0` | do not use hand tracking; the controller stays at its fixed spot | +| `sharpen=0` | no sharpening of the picture. Default 1: the emulator sharpens every frame of the game once. 2: the headset's Super Resolution filter on every refresh instead (finer; about a twentieth of the GPU's time). 3: that filter whenever the system finds the GPU has time for it (in a level: hardly ever). 4: the headset's plainer filter. See "The picture" | +| `cubic=1` | have the headset enlarge the picture with a cubic filter instead of a linear one (sharper, for some GPU time on every refresh) | +| `stick_touchpad=0` | right stick no longer doubles as a finger on the touchpad | +| `motion=0`, `rumble=0` | ignore the motion sensors / no vibration | +| `msaa=4` | let the game multisample as on the console (default 1 = off, much faster) | +| `stats=1` | keep a small panel in view with the game's frame rate, the display's refresh rate and whether the hands holding the controller are seen | +| `predict_ms=25` | how far beyond the next refresh the head pose given to the game is predicted (0–80). More if the picture's edges show when turning the head, less if the world wobbles | +| `dynamic_resolution=0` | do not ask the system what size it recommends for the picture (which may cost the GPU its fastest clock). `2`: also show the picture at that size, as up to version 0.6. Default: ask, and show the picture at full size, see "The picture" | +| `cpu_boost=0` | do not ask for the processor's "boost" level (its fastest clock, which the system grants for the first 45 seconds and up to a fifth of the time after) | +| `fov=100` | how much of PlayStation VR's field of view the game draws, in percent (50–120). **Default 85 since app 0.9**: about 91 by 94 degrees an eye instead of 100 by 103, the same pixels over fewer degrees, so 18% more of them to the degree, with a black border where the rest was (it costs the GPU nothing). `100` is what the game draws on a PlayStation VR (50.4°/49.8° out/in, 51.6° up and down an eye); `80` or `75` sharper still and narrower. host.log says what was used ("the game draws 85% of PlayStation VR's field of view") | +| `mic=0` | the game does not get to hear the headset's microphone (see "Microphone") | +| `mic_gain=2` | make what the game hears that many times louder (0.1–30) | +| `arg=...`, `env=NAME=value` | extra emulator argument / environment variable | + +What a session leaves behind, in the same folder as `vrhost.txt`: + +| File | Content | +| --- | --- | +| `host.log` | the app's own log: settings, controller found and what it offers, the OpenXR session, and every ten seconds a line with the game's frame rate against the display's, the processor time and memory the emulator used and the cores it ran on, a line on where the head is in the headset's own space and how far it moved, a line on what was seen of the hands and where the controller was taken to be, every reset of the view and what asked for it, the VR runtime's own counters ("runtime:": GPU load, the compositor's time, frames it had to repeat, load per processor core), and how loud the microphone was | +| `core.log` | the emulator's output, with a few lines every five to ten seconds on the frame rate and what a frame's time goes to, on how each sound port keeps up and on what the game's microphone port heard; "The title's clock" (how long frames take, the time step the game is given, the speed it ran at, the size it draws at, how many refreshes a frame is given and how busy the GPU was), "The scene is drawn at" and "Frames are given ... refreshes" (every change of size and of pace, and why), "The title has the player's seat at" (where the game takes the player to sit and where the head is from there: near zero when the view is right), "Seat recentred" (every reset of the view), "The headset refreshes ... after the host's display" (how the emulated headset keeps step with the real one) | +| `host.prev.log`, `core.prev.log` | the same of the start before the last one | + +`adb pull /sdcard/Android/data/com.astrobotquest.vrhost/files/host.log` fetches one; they are +what to look at (or send along) when something did not work. `adb logcat -s AstroVR` shows the +host's log live. The emulator's own folder (saves, `sys_modules`) is `.../files/data/shadPS4/`. + +## Where the player sits + +The game takes the place of the player's head once, from the first position the tracker gives +it a few seconds after it starts, and from then on places everything around that spot; it never +asks which way the player faces, because a PlayStation VR player faces the camera. It takes +stock again only when the console says the view was reset, or when OPTIONS is held. (Not when a +level starts: with the head half a metre forward of where it was at the start, the PC build +loads the first level and stays half a metre forward.) On the Quest the first position is +wherever the head was a few seconds after the app was started, in a space whose origin and +heading are the headset system's affair. In the second session that put the player ahead of +where the game meant them to be for the whole session: the hero stays 0.4 to 1.1 m in front of +that spot, so less than half a metre is enough to stand on top of him. + +The emulator now keeps the player's seat itself (`src/core/vr/vr_runtime.cpp`): the position and +heading of the head at the moment the view was last reset. What the game is given is counted +from there, and with every reset it is sent what the console sends, so that it takes stock too. +The view is reset when the first pose arrives, when the game first asks for one, when ✕ is +pressed for the first time (the player has settled, controller in hand, looking at the title), +when OPTIONS is held for a second or the PS button is pressed, and when the headset's own reset +is used. `core.log` says each time where the seat is, and every ten seconds where the game takes +the player to sit and where the head is from there. + +## Speed + +**The game counts time in frames.** It moves its world on by a sixtieth of a second for every +frame it draws, however long the frame took. On the console that is the same thing; here it is +not, and in the first two sessions the whole game ran at little more than half its speed (30 to +35 frames a second). The emulator now gives it, frame by frame, the time its frames really take +(the engine keeps its step in three variables, written by the one function that sets its frame +rate; `src/core/known_title.cpp`). Slowed down to 43, 30 and 22 frames a second, the PC build +then follows the same course to the second as at 60, and a scripted walk through the first level +has the hero in the same places at the same moments. Below 20 frames a second the game slows +down rather than take steps its physics were never tried with. `real_time=0` turns this off. + +**Two refreshes for a frame, or three.** The game draws a frame for every two refreshes of its +headset (60 frames for the 120 Hz of a PlayStation VR) when it manages. When a frame takes +longer it goes straight on to the next one, at whatever rate that makes, and that rate has +nothing to do with the display's: at 33 frames a second on a display of 72 Hz one frame is on +show for two refreshes, the next for three, as they happen to fall, and whatever moves in the +picture moves in jerks. That is what the first level was like up to version 0.6. + +The emulated headset refreshes with the Quest's display. The app tells the emulator of every +refresh; the emulated headset keeps step with those and refreshes at the moment after them that +has the game's frames arrive midway between two looks of the app (a clock of its own would +drift against the display). From 0.7 on it refreshes more slowly than the display wherever the +game cannot keep the display's pace: one and a half times as slowly, so that the game's two +refreshes are three of the display's. The app asks for 90 Hz now. That makes 45 frames a second +where the game manages a frame in two refreshes (title, menus, world map, lighter scenes) and +30 where it takes three (the levels), and either way every frame is on show for exactly as long +as the next. In the self-test, with a display and a compositor of 90 Hz standing in, 292 to 300 +of 300 frames stay for exactly three refreshes in the first level's ordinary views, and 87 to +96 of 100 in its heaviest. Head movement is smooth at the display's rate regardless: the +compositor turns the last frame to where the head points by now. + +Frames are never given more refreshes than still makes 30 frames a second: a game that cannot +do that either is left to draw as fast as it can. At `refresh_rate=72` and `80` there is +therefore only the one pace (36 and 40 frames a second), and the levels run beside the display +as they did; at `120` there are three (60, 40 and 30). `pace=` holds the game to one number of +refreshes throughout. + +(What does not work is holding a finished frame back until its refresh: the game does not wait +for its frames to be shown, so they pile up behind the one that is held - a tenth of a second +late on the PC, seconds on the headset. The first attempt did that.) + +**The size of the picture.** The game draws its scene at one of four sizes (816x870, 960x1080, +1200x1280 or 1440x1536 an eye; a base PlayStation 4 moves between the last three, and only goes +down to the first in a few levels), enlarges it to 1440x1536 itself and hands that to the +headset. It chooses the size by how long it finds the GPU to take over a frame, and emulated, +the clock it reads for that says how long the emulator took to pass the drawing on, not how +long the GPU needs for it. The emulator therefore chooses in its place, pace and size together +(`Governor` in `src/core/known_title.cpp`). It looks eight times a refresh whether the GPU +still has work of the game's before it, and goes by that and by how long frames take: + +- frames that fit the refreshes they are given take exactly that long, on average; frames that + take 3% longer do not fit; +- the pace is the fastest at which 960x1080, the console's own smallest, fits the GPU's time + with a tenth to spare. Only at the slowest pace there is (30 frames a second) will 816x870 do; +- the size is the largest that fits the pace with 15% to spare, by what the sizes were seen to + cost (the three larger ones are counted as 8%, 27% and 54% more GPU time than 816x870, the + upper end of what was measured); +- when frames stop fitting and the GPU is what holds them up (busy 85% of the time or more), it + goes straight to the size, and if need be the pace, that the GPU's time says will fit; when + it is the game's own work that takes long, to the next pace; +- a step up, in size or in pace, that had to be taken back within seconds makes the next one + wait twice as long (6 seconds to 2 minutes), and counts the size as dearer. + +Up to 0.6 the size went back and forth between 816x870 and 960x1080 all through the first +level (fourteen times in six minutes of the third session): at 72 Hz the smaller one used 78 to +94% of the GPU's time and the larger one did not fit. With three refreshes of 90 Hz for a frame +there is room. In the self-test's first level (GPU at 690 MHz, compositor stand-in at 90 Hz): +1200x1280 at 30 frames a second with the GPU busy 78% of the time in its ordinary views, 816x870 +at 30 with the GPU busy 97 to 99% in its heaviest (the whole level in view), 1440x1536 at 45 in +the world map. A session has a slower GPU clock (599 MHz): expect the heaviest views to fall a +little short of 30 there, and the ordinary ones at 960x1080 to 1200x1280. `resolution=` holds +the game to one size, `resolution=game` leaves the choice to the game. + +Measured on a Quest 3 in the first level, without the headset worn (`tools/quest-sandbox-test.sh`): +about 30 frames a second before the changes below; after them 59 at the start of the level (860 +draws per frame) and 40 to 42 looking down the whole level (1800 draws), where GPU and processor +are both at their limit. A real session differs: the emulator has three processor cores of its +own there (3 to 5, at 1.92 GHz), the GPU runs at 599 MHz at most (690 in the sandbox), and the +compositor takes 0.7 to 1 ms of it at every refresh. The second session (app 0.5, at 120 Hz): +40 to 56 frames a second in the prologue, 21 to 40 in the first level, with the GPU 97 to 99% +busy and the emulator using two of its three cores. The third (app 0.6, at 72 Hz): 33 to 36 in +most of the level and 24 to 32 at its start, at the game's proper speed. The self-test can +stand in for that: `HOST_COMPOSITOR=90` among its settings takes the GPU away from the emulator +the way the compositor does, which makes the GPU the limit there too (its frame rates times +0.87 for the slower clock are about what a session gets), and `tools/quest-level-bench.sh` runs +it into the first level that way. + +Three programs share the GPU in a session: the emulator, this app (which copies each finished +picture to where the compositor takes it from) and the compositor. Left to itself the driver +treats the first two as equals, and the app's millisecond of copying then waits behind everything +the emulator has queued for the pictures after it: in that first session up to 54 ms, with the +app's own frame loop down to 42 rounds a second. The emulator's GPU work therefore runs at the +lowest of the kernel driver's priority levels (`KGSL_COMPAT_PRIORITY=12`, set by the app; the +Mesa driver has no way to ask for that itself, the library that sits between it and the kernel +does it). In the self-test, with the GPU kept busy by 4x multisampling, the copy went from 15 to +38 ms on average (76 at worst) to 1.5 ms (9 at worst), and the game got 15% more frames out. + +What made the difference, in the core (`shadps4-arm64-main`): + +- The frame's GPU commands are handed to the driver in parts while the frame is still being + translated, not all at once at its end, so that the GPU works at the same time as the thread + that feeds it (`SHADPS4_FLUSH_DRAWS`, 64 draws by default on the headset build). +- Images are created with the list of formats they will be viewed in. Without it Turnip has to + store every colour image uncompressed and untiled. +- A render pass is no longer ended by a change that does not need it (a target that has just + been cleared, depth writes being switched off and on): 113 passes per frame became 52. +- Per-draw work of the GPU thread that only repeated itself is remembered (fetch shader layout, + texture descriptions and lookups, image layout transitions), and a pipeline that is already + bound is not bound again (which made the driver resend its state to the GPU). +- A finished frame is flipped when the GPU is done with it, not at the next refresh. +- The emulator has more busy threads than the headset has cores for it. The sound thread and the + two threads every frame passes through get a higher priority than the game's helpers + (`SHADPS4_THREAD_NICE`, set by the app). (The VR runtime's own thread hints are not available + for them: it only accepts threads of the app's process, and the emulator is a process of its + own.) +- The GPU driver draws directly instead of in tiles (`TU_DEBUG=sysmem`, set by the app while + multisampling is off). + +What is left is what the game draws. Looking down the first level that is about 8 million +vertices a frame (shadow maps a third, a depth pass for each eye a fifth, the two colour passes +the rest), in 1850 draws; `SHADPS4_FRAME_STATS=1` logs the count, `=2` lists it pass by pass. +With every draw cut down to one triangle (`SHADPS4_DBG_DRAW_VERTICES=3`, a measuring aid) the +GPU still has a third of its work: about 4 microseconds per draw for the state that changes +between draws, the other two thirds being the geometry and its pixels. The frame rate of that +view does not rise by it, though: there the game's own threads and the thread that translates +its draws (20 ms a frame) are the limit in the sandbox, where the emulator has three cores. + +In a VR session the system holds the GPU at 545 MHz at most (level 4), and lets it go to 599 +(level 5) only for apps that take part in "dynamic resolution": that ask it, from moment to +moment, at what size it wants their picture. The app asks (and up to 0.6 also showed the +picture at that size, see "The picture"); `dynamic_resolution=0` turns the asking off. Whether +the system grants the higher level shows in what `tools/quest-recorder.sh` keeps of a session +(`GPU=4/5`, `.../599MHz` in the `VrApi` lines, `Dynres boost enabled` among the reasons for the +GPU's maximum). In the second and third sessions it did: level 5, 599 MHz throughout. + +The last level, 640 MHz, the system only gives to an app that also trades a processor level for +it, which is a line in the app's manifest and so a build of its own: +`quest-host/build.sh --trade-cpu-for-gpu`. The processor then tops out at 1.65 instead of +1.92 GHz, 14% less for 7% more GPU. In the second session the GPU was the one that ran out, +with the emulator using two of its three cores; but the thread that hands the game's drawing to +the GPU is one of the two, and it is the one a slower processor would hold up. Not tried in a +session; the default build does not trade. + +The app also asks for the processor's "boost" level, which the system grants for the first 45 +seconds and up to a fifth of the time after that (2.36 GHz): that is when the emulator +translates most of the game's code. `cpu_boost=0` turns it off. + +Tried and dropped: FEX without x86 memory ordering (`SHADPS4_FEX_TSO=0`) - the game stops within +half a minute. The driver without its lowering of uniform buffers to constants +(`IR3_SHADER_DEBUG=nouboopt`) - the same GPU time. Not setting vertex layout, vertex and index +buffers and push constants again when they are what the command buffer already has (half of +those calls) - no difference to the GPU or to the thread that makes them. + +The app has the core log, every five seconds, the frame rate, what a frame consists of and how +long it takes on each part of its way ("frame path", `SHADPS4_FRAME_STATS=1`). The tools under +"Testing on the headset" show where GPU and processor time go. + +### The headset's own performance features + +What Meta offers apps for speed, and what each can do for a game that is drawn by an emulator +(checked against Meta's documentation; the pages are in `build/docs/`): + +- **Application SpaceWarp** has the app draw at half the display rate and the compositor make up + every other frame. For that the app hands over, with every frame, a buffer that says for each + pixel how it moved since the frame before, and the depth buffer; whatever is drawn without + such motion vectors "appears to stutter". A game engine writes them in a pass of its own, from + each object's transform in this frame and the last. This game has no such pass (among its + render targets in the first level there is no velocity buffer), so the emulator would have to + work out, for each of the game's 1800 draws a frame, where the same draw put its vertices a + frame earlier, and draw all of it once more. That is a project of its own with an uncertain + end, and the extra pass would cost frame rate that is already short of the exact half rate + SpaceWarp insists on (60 for 120 Hz, 40 for 80 Hz, 36 for 72 Hz). Not done. + What the compositor does do with every frame, at the display's rate, is turn it to where the + head points by now. That is the same reprojection PlayStation VR used to show this game's 60 + frames at 120 Hz. +- **Fixed foveated rendering** makes the GPU draw the edges of the image an app renders into at + a lower resolution. The image this app renders into only receives a copy of the finished + picture, which is no work to speak of. The picture itself is drawn by the emulator into the + game's own targets; there the driver could only do it in its tiled mode, which halves the + frame rate of this game (it is the geometry that is expensive, not the pixels, and the game + already draws at its lowest resolution, with the area the lenses cannot show masked out). +- **Super Resolution** is the better of the two filters the compositor can enlarge the picture + with. Left to the system (the default up to 0.6) it was off two thirds of the time in a + level; `sharpen=2` now asks for it unconditionally, the default is the emulator's own + sharpening (see "The picture"). +- **GPU and processor levels**: see above. + +## The picture + +In the third session the game was up to speed and the view was right, and the picture "looked +way worse" than on the console. It did, for four reasons, of which the size of the scene was +only one: + +- **No anti-aliasing.** The console draws this game with multisampling (four colour samples + and eight depth samples a pixel). On the Quest that is switched off (`msaa=1`): two samples + cost 9 to 28% of a frame's time, four 28 to 40%, which is more than there is. Every edge was + therefore as jagged as its pixels, and the headset's display, which has about two and a half + pixels across for each of the picture's, shows every step. From 0.7 on the emulator smooths + edges in the finished scene instead: where the game "resolves" a multisampled picture that + the emulator holds with one sample a pixel, there is nothing to average, and the copy that + used to stand in for it is now a filter that finds edges by their contrast and blends each + pixel on one with its neighbour across it, by how far along the edge it sits (FXAA; it works + on the scene before tone mapping, so a glaring pixel does not decide everything around it; + `src/video_core/host_shaders/resolve_aa.frag`). It costs about 3% of a frame's time (1 ms at + 816x870) and is not tied to this game. `antialias=0` turns it off. +- **The size**, see above: 816x870 for half of the level. +- **Shown smaller.** Up to 0.6 the app showed the picture at the size the system recommended + from moment to moment, 15% smaller in each direction whenever the GPU was busy, which in a + level is always. That saved nothing worth having (the picture is copied once per frame of + the game) and blurred what the game drew. Now the app still asks for the recommendation, + which is what the system wants of an app before it lets the GPU run at its faster clocks, + and shows the picture at full size. Whether the system still grants the faster clock (599 + MHz, "level 5") that way is the first thing to look for after the next session: `GPU=4/5` + and `599MHz` in the `VrApi` lines that `tools/quest-recorder.sh` keeps. + `dynamic_resolution=2` goes back to showing the picture at the recommended size. +- **No sharpening.** The headset was asked for its Super Resolution filter "when the system + finds the GPU has time", and the system found that in a third of the level. Now the emulator + sharpens each picture itself as it copies it to where the app takes it from (contrast + adaptive sharpening; `post_process.frag`), which costs too little to measure and happens + once per frame of the game instead of at every refresh. `sharpen=2` asks for Super + Resolution on every refresh instead, whatever the GPU is doing (it takes about 0.7 ms of + every refresh, a twentieth of the GPU at 90 Hz); `sharpen=0` leaves the picture soft. + +`build/quest/picture-compare.png` shows three parts of the first level's picture as 0.6 showed +them, as 0.7 does in the heaviest views and in ordinary ones, and as a PlayStation 4 draws +them at its smallest and largest size (made from full-size dumps of the PC build by +`tools/picture-compare.py`). + +How this compares with the console: a base PlayStation 4 shows this game at 60 frames a second, +960x1080 to 1440x1536, multisampled. The Quest 3 running it through an emulator shows the +levels at 30 frames a second, each frame for the same time, at 960x1080 to 1200x1280 in most +views and 816x870 in the heaviest, with edges smoothed by a filter instead of by multisampling; +lighter scenes at 45 frames a second and up to 1440x1536. Half the console's frame rate is what +the headset's GPU has in it for this game (a frame of the first level is 4 to 8 million +vertices in 750 to 2500 draws, 20 to 30 ms of GPU time at the smallest size); the picture is +now close to the console's at its smaller sizes. + +## Sound + +The game does all its sound through Sony's Ngs2 library, which the emulator only had as an empty +stub. `src/core/libraries/ngs2/ngs2_engine.cpp` implements what the game uses natively: sampler +voices (ATRAC9, HE-VAG, PCM), submixers, reverb, chorus/delay/pitch racks, mastering, and the +game's own effect callbacks. The game's 7.1 mix is rendered for the headset's ear speakers by a +virtual surround stage (`audio/surround_virtualizer.cpp`); `env=SHADPS4_VIRTUAL_SURROUND=0` +replaces it by a plain fold-down. The second mix the game produces for the television is not played. + +The app plays each port on its own audio stream. The stream's buffer (60 ms) is what stands +between a game that is late for a moment and a gap in the sound: the emulator delivers as fast +as the stream takes it, and after a delay hands over what it missed at once, which fills the +buffer again. A stream that takes nothing at all (output suspended or rerouted) is not waited +for: its sound is dropped until it plays again, so the game never waits for sound nobody hears. +`host.log` has a line per stream every ten seconds: how much sound was delivered, dropped and +played, and how often the buffer ran dry. (In the second session the stream of the game's 3D +sound ran dry some 130 times in the ten seconds the first level took to load, and hardly ever +otherwise: the thread the game mixes it on, and the emulator's threads that pass sound on, had +no more claim to a processor than the game's helpers, which are busiest while a level loads. +They are now among the threads `SHADPS4_THREAD_NICE` puts first.) + +(In the first session there was no sound at all: Android only starts to play a stream once its +buffer has been filled completely, and the app held back everything beyond a "cushion" that was +smaller than that.) + +To check sound without listening: `SHADPS4_AUDIOOUT_DUMP=<seconds>` writes what every port plays +to WAV files in the emulator's user folder (`tools/wavstat.py <file> --png out.png` summarises one); +`SHADPS4_AUDIOOUT_STATS=1` logs every ten seconds how much of real time each port played and what +held it up. + +## Microphone + +The game listens to the microphone PlayStation VR has in its visor: blowing at things is one of +the ways to play with its world. The app passes the headset's own microphone on for that, and +asks for the permission the first time it starts; without it (or with `mic=0`) the game hears +silence, as it did before. + +All the game does with the sound is measure how loud it is: 256 samples at a time, and from +their root mean square `rms` (1 being full scale) a strength of blowing +`min(1, 0.5 * ln(1 + 3.5 * 20 * log10(1 + rms / 1.5)))`. That is 1 from -9 dB on, a half at +-21 dB and a quarter at -30 dB. `host.log` says every ten seconds how loud the loudest moment was +on that scale, which is what to set `mic_gain` by should blowing do too little (or talking too +much). In an input script `mic=0.35` blows for as long as the line lasts, and +`SHADPS4_AUDIOIN_STATS=1` makes the emulator log what the game's port heard. + +## Other firmware libraries + +`src/core/libraries/json/json.cpp` implements the firmware's JSON library (libSceJson2), which the +emulator only stubbed. The game hands it the animation sequences of characters and sets of option +flags; with the stub every such text read as empty. `tools/tests/json_test.cpp` exercises it the +way the game calls it, and `SHADPS4_JSON_TRACE=<count>` logs what is parsed. + +## PC test build + +`tools/run-win.sh <seconds>` runs the game in the Windows build with a simulated headset. Useful +environment variables: `SHADPS4_VR_DEMO=1` (sweeps the head), `SHADPS4_INPUT_SCRIPT=<file>` (scripted +buttons, sticks, touchpad, head, controller and hand positions, a reset of the view, see +`shadps4-arm64-main/src/input/scripted_input.h`; examples in `build/dev/`). `tools/contact.mjs` +turns the automatic screenshots into a contact sheet. + +`tools/pc-view-test.sh <name> <seconds> <"x,y,z"> [input script]` runs it with the head resting +at a given place and keeps pictures and log in `build/dev/view/<name>/`. For telling what the +game does with time and with the head, on a machine that is fast enough for anything: + +| Setting | Result | +| --- | --- | +| `SHADPS4_DBG_FRAME_DELAY_MS=<ms>` | holds the game up by that much every frame (22 gives 43 frames a second, 32 gives 30) | +| `SHADPS4_SHOT_SECONDS=<n>[,<from>]` | a picture every n seconds by the clock, so that runs at different frame rates can be compared moment by moment | +| `SHADPS4_FRAME_STATS=1 SHADPS4_FRAME_STATS_EVERY=1` | frame rate and draws per frame every second: what the game shows over time, as a fingerprint of where it is | +| `SHADPS4_VR_REFRESH_RATE=<Hz>` | how often the emulated headset refreshes (60 to 120); the game draws half as many frames | +| `SHADPS4_VR_PACE=<2..6>` | how many of those refreshes every frame is given: 3 at 90 Hz makes 30 frames a second on the dot (without it the emulator chooses, which on a PC is always 2) | +| `SHADPS4_TITLE_TIMESTEP=0`, `SHADPS4_TITLE_RESOLUTION=<3..6 or title>` | the game's time step left alone; its scene held to one size (3 = 816x870 ... 6 = 1440x1536) or left to the game | +| `SHADPS4_MAX_MSAA=<1, 2, 4>` | the most samples a pixel gets; 1 is what the headset runs with, and has the emulator smooth edges itself unless `SHADPS4_RESOLVE_AA=0` | +| `SHADPS4_VR_SHARPEN=<0..1>` | how much the eyes' pictures are sharpened on their way out (the app sets 0.6) | + +`tools/pc-dump-test.sh <name> <seconds> [NAME=value ...]` plays into the first level and keeps +everything the game has drawn at that moment, at full size, in `build/dev/dump/<name>/` (the +eyes' finished pictures are the `..._523ce0000_1440x1536_...` and `..._5245e0000_...` files, +the scene before the game enlarges it the `960x1080_R16G16B16A16Sfloat` ones, or whatever size +it was held to). `tools/crop.py` cuts the same part out of several of them and puts the cuts +side by side, `tools/picture-compare.py` makes the comparison in `build/quest/picture-compare.png`, +and `tools/aa_proto.py` is where edge smoothing, enlarging and sharpening were tried out on +such dumps before any of it was written for the GPU. + +`build/dev/input-gametime.txt` and `input-playcheck.txt` are the scripts the time step was +checked with, `input-origin2.txt` the one that shows when the game takes stock of the head. + +## Testing on the headset without wearing it + +`tools/quest-sandbox-test.sh <seconds> [input script]` runs the core inside the app's sandbox with +scripted input and pulls log, screenshots and audio dumps to `build/quest/run/`; +`tools/quest-selftest.sh <seconds>` exercises the app's own launch, socket and frame-sharing code. +Neither needs the headset to be unlocked; only the immersive session itself does. + +Settings of `quest-sandbox-test.sh` for looking into speed (all described at the top of the script): + +| Setting | Result | +| --- | --- | +| `SHADPS4_FRAME_STATS=1` (as an argument) | frame rate, passes, draws and the frame path in `run/core.log`; `=2` also lists the render passes of a frame and which code ended each | +| always | `run/gpu.txt`: GPU load, GPU and processor clocks every five seconds | +| `ASTRO_GPUTRACE_AT=<s>` | the driver's own trace from that second on; `tools/gputrace.py run/gputrace.txt <fps>` sums it up per kind of render pass | +| `ASTRO_THREADS_AT=<s> ASTRO_THREAD_SAMPLES="1500 shadPS4:GpuComm"` | a sampling profile of one thread; `node tools/symbolize-stacks.mjs --thread shadPS4:GpuComm --profile` prints it | +| `ASTRO_AT="<s>:<command>;..."` | shell commands at given times, e.g. to switch driver options through `TU_DEBUG_FILE` | + +The sandbox is not a VR session: the core may only use three processor cores there, and the GPU +clock follows the load instead of being held by the VR runtime. + +Settings of `quest-selftest.sh` that make it more like one (given like the core's, as +`NAME=value` arguments): + +| Setting | Result | +| --- | --- | +| `HOST_COMPOSITOR=<Hz>[,<n>[,<Mpx>]]` | a stand-in for the compositor: so many times a second a pass the size of the compositor's own (9 megapixels) and n - 1 small ones (n = 5), on a GPU context that comes before the emulator's. With it the GPU is the limit as in a session | +| `HOST_DISPLAY=<Hz>` | the test's loop goes round once per refresh of a display of that rate, tells the emulator of each as the app does, and counts for how many refreshes each frame of the game stayed the newest | +| `HOST_LOOK="<s>:<left>,<up>;..."` | where the head looks from which second on (degrees); `8:85,22;110:0,-12` finds the first level from the world map and then looks along it | +| `XDG_DATA_HOME=<folder>` | where the emulator keeps its data, saves among them. The self-test starts from nothing each time, so the game plays its prologue (four minutes); with a folder that holds a save it is in the first level after 75 seconds | +| `SHADPS4_VR_FOLLOW_DISPLAY=0` | the emulated headset keeps to its own clock although the host tells of its display's refreshes | + +`quest-selftest.sh` gives the game's microphone a test signal (a second of noise every five); +`ASTRO_MIC=real` opens the headset's own instead, which stays silent while nobody wears it. +`ASTRO_FRESH=1` makes it unpack the runtime from the installed app first, as the app does on its +first start, instead of testing the core in `build/arm64`. (Both test scripts otherwise put that +build into the app's runtime folder and remove the folder's stamp, so that the app unpacks its +own again the next time it is started.) + +`tools/quest-level-bench.sh <name> <seconds>` is the self-test set up for measuring: a display +and a compositor stand-in of 90 Hz (`BENCH_HZ=72` or `120` for others), a save that has the game +in the first level after 75 seconds (the folder `bench-data` in the app's files, a copy of the +sandbox tests' save), the head looking at the level sideways until second 110 and down its +whole length after that, which is its heaviest view. It keeps report, logs and the GPU's clock +in `build/quest/bench/<name>.*` and prints what `tools/quest-bench-read.sh <name>` prints: +frames a second by ten seconds, for how many refreshes frames were shown, every decision on +pace and size, and every ten seconds what frames took at what size with the GPU how busy. +(`tools/quest-gpu-watch.sh <seconds> <file>` on its own writes GPU load, clock and temperature +once a second.) The self-test does not take one of its own settings twice: give `HOST_DISPLAY` +and `HOST_COMPOSITOR` once. + +`tools/quest-xrprobe.sh` goes as far into OpenXR as the runtime lets an app go with nobody +wearing the headset: it checks that the app finds the runtime and that the extensions the host +uses are there, and then runs the host itself for five seconds - session, swapchains, hand +trackers and the frame buffers shared with the emulator are created as in a real start, the +session (which stays idle) is asked for the refresh rates on offer, the performance levels and +the thread hints, and a test picture is copied into the swapchain's images and read back. On +Horizon OS 207 all of that succeeds (72, 80, 90 and 120 Hz on offer). What it cannot reach is the +session itself: frames on the display, head and hand tracking, the controller. + +`tools/quest-drystart.sh <seconds> [settings file]` starts the app's own activity without showing +it: everything the app does when it is launched runs (settings, log files, OpenXR up to the idle +session, unpacking the runtime, the emulator with the game, sound), a controller that is not +there presses ✕ now and then (through the same code a real one's events go through), and the +`host.log` and `core.log` the app writes are pulled to `build/quest/drystart/` together with +pictures of what its status panel showed. + +## Watching a real session + +A session is played without a cable, so what the app cannot see itself is written down on the +headset: `tools/quest-recorder.sh start` leaves a small recorder running there (until the +headset is restarted; starting it again is harmless). Whenever the emulator runs it keeps, in +`/data/local/tmp/astro/sessions/<start time>/`, the VR runtime's own statistics (`VrApi` lines +once a second: frames shown and stale, processor and GPU level and clock, GPU time of the app +and of the compositor; `crcs` lines: every change of clock level and the reason for it), GPU +load, clock and temperature every two seconds, and the emulator's busiest threads with the cores +they ran on every thirty. + +`tools/quest-recorder.sh pull`, with the headset back on the cable, fetches all of it to +`build/quest/sessions/`, with the app's `host.log` and `core.log` next to the newest session. +`status` says whether the recorder runs and what it has. + +What to read first after a session with 0.7: in `core.log`, "Frames are given ... refreshes" +and "The scene is drawn at" (how often pace and size changed, and between what), and the +ten-second lines "The title's clock" (frames at 33.3 ms with the GPU under 90% busy is the level +running as intended; frames longer than they are given with the GPU at 100% is the GPU short). +In the recorder's `VrApi` lines, `GPU=` and the clock after it (level 5, 599 MHz, is what the +app had so far while it showed the picture at the recommended size; it now only asks for that +size), `FPS=` against the display's 90, and `Stale`. In `host.log`, the "controller:" lines +(vendor 1356 is Sony) and "picture shown at" (1440x1536, and what the system recommended). + +(`tools/quest-session-watch.sh` does the same from the PC, for a headset that stays connected.) + +Should the game stop drawing, the app's panel says so after twenty seconds ("No new picture +from the game for ... seconds") instead of "Loading...", and the emulator writes what each of +its threads was doing into `core.log`; `node tools/symbolize-stacks.mjs <core.log>` turns that +into function names. The one such stop met so far is described in +`shadps4-arm64-main/src/video_core/renderer_vulkan/vk_master_semaphore.cpp`. diff --git a/README.md b/README.md new file mode 100644 index 0000000..34e1e4b --- /dev/null +++ b/README.md @@ -0,0 +1,197 @@ +# AstroQuest + +**ASTRO BOT Rescue Mission (PS4 / PlayStation VR) in virtual reality on Meta Quest 3**, played +from your own copy of the game through a PS4 emulator. Two ways to play: + +- **On the headset alone**: an app for the Quest 3 runs the emulator on the headset itself. No + PC is needed once it is installed. +- **On a Windows PC, shown in the Quest through Virtual Desktop**: the PC runs the game at the + console's 60 frames a second and at up to six times its resolution. + +The emulator is [shadPS4](https://github.com/shadps4-emu/shadPS4) (its ARM64 build, +[zenithblue-oss/shadps4-arm64](https://github.com/zenithblue-oss/shadps4-arm64), on the +headset), to which this project adds what the game needs from a PlayStation VR: the headset, +its tracking and reprojection, the camera's view of the controller (taken from the Quest's +hand tracking), the 3D sound engine, the microphone, and fixes for the game's timing and +resolution under emulation. + +> **No game files are included or distributed.** You need your own copy of ASTRO BOT Rescue +> Mission, dumped from your own PlayStation 4. + +| | PlayStation 4 + PS VR | Quest 3 on its own | PC + Virtual Desktop | +| --- | --- | --- | --- | +| Frames a second | 60 | 30 in levels, 45 in lighter scenes | 60 (more if you ask for it) | +| Picture per eye | 960x1080 to 1440x1536 | 816x870 to 1440x1536 | 1440x1536 up to 3600x3840 | +| Edges | multisampled | smoothed by a filter | multisampled | + +## Status + +Work in progress, built and tested by one person on one Quest 3 and one PC. World 1 (levels +1-1 to 1-4) has been played through on the Quest 3 on its own; the PC path has been played +over Virtual Desktop and fixed since. Expect rough edges, and please report what you find. + +## What you need + +- **A Meta Quest 3.** (The Quest 3S has the same chip and should work, but nobody has tried.) +- **A PS5 DualSense controller.** It stands in for the PS4 controller the game expects: + buttons, sticks, touchpad, motion sensors, rumble and light bar. (A DualShock 4 may work + too; untested.) On the PC the Quest's own Touch controllers can stand in for it. +- **ASTRO BOT Rescue Mission, European release CUSA12392, version 1.00**, as the folder of an + extracted game (the one with `eboot.bin`, `sce_sys`, `sce_module` in it, about 13 GB), + dumped from your own console and game. Other regions and versions are untested, and the + fixes for the game's timing and resolution only apply to this one. +- To install on the headset: a computer with + [adb](https://developer.android.com/tools/releases/platform-tools) (or + [SideQuest](https://sidequestvr.com/)) and the headset in + [developer mode](https://developers.meta.com/horizon/documentation/native/android/mobile-device-setup/#enable-developer-mode) + (set in the Meta Horizon app on your phone; on Windows, adb may also need Meta's ADB + driver, described on the same page). +- To play on the PC: Windows 10 or 11 (64-bit), a graphics card with Vulkan 1.3, the + [Microsoft Visual C++ Redistributable (x64)](https://aka.ms/vs/17/release/vc_redist.x64.exe), + and [Virtual Desktop](https://www.vrdesktop.net/) (the app on the Quest, the Streamer on the + PC). + +## Installing: Quest 3 on its own + +Download `AstroQuest-<version>-Quest3.apk` from the +[latest release](https://github.com/bigmak94/AstroQuest/releases/latest), then: + +1. **Install the app.** Connect the headset to the computer with a USB cable, allow USB + debugging in the headset, and run + + ```sh + adb install -r AstroQuest-0.11-Quest3.apk + ``` + + (or drag the APK onto SideQuest). +2. **Copy the game to the headset**, the folder named `CUSA12392` (this takes a few minutes): + + ```sh + adb push CUSA12392 /data/local/tmp/astro/games/ + ``` + + The app also finds it in `/sdcard/Android/data/com.astrobotquest.vrhost/files/games/CUSA12392`, + but that folder is deleted with the app if it is ever uninstalled. +3. **Pair the DualSense with the headset**: Settings > Bluetooth > Pair, and on the + controller hold Create and the PS button until the light bar flashes. +4. **Start "Astro VR Host"** from the App Library, under *Unknown Sources*. The first start + takes a few seconds longer (it unpacks the emulator) and asks for the microphone: the game + listens to it for blowing at things, as it did with PlayStation VR's. + +Playing: + +- Put the Touch controllers aside and hold the DualSense: the headset tracks your hands around + it, and that is where the controller is in the game. +- The first screen asks to move the controller into a floating outline: hold it up in front + of you where the outline is. +- On the world map, **look** at a planet and press ✕. +- **Reset the view** by holding OPTIONS for a second (or pressing the PS button) whenever you + sit differently and things are too close, too far or off to one side. +- Taking the headset off pauses the game. +- Settings (refresh rate, resolution, field of view, sharpening, microphone gain...) go in + `/sdcard/Android/data/com.astrobotquest.vrhost/files/vrhost.txt`; all of them are explained in + [README-QUEST-VR.md](README-QUEST-VR.md). + +Your saves are kept in `/sdcard/Android/data/com.astrobotquest.vrhost/files/data/shadPS4/home/1000/savedata`. +Updating the app with `adb install -r` keeps them; **uninstalling deletes them**, so copy that +folder off the headset first (`adb pull`). + +## Installing: PC VR through Virtual Desktop + +Download `AstroQuest-<version>-PC-VR-Windows.zip` from the +[latest release](https://github.com/bigmak94/AstroQuest/releases/latest), then: + +1. **Unzip it** into a folder with a short path, e.g. `C:\Games\AstroQuest`. Some of the + game's files have long names, and the emulator cannot open a file whose full path is + longer than Windows' 260 characters: keep the path of the folder that holds `games` under + about 110 characters. +2. **Put the game in its `games` folder**, so that `games\CUSA12392\eboot.bin` exists (or + point `game=` in `pc-vr\settings.txt` to wherever your `eboot.bin` is, on a path just as + short). +3. **Set up Virtual Desktop**: install the Streamer on the PC and, in its Options, choose + **VDXR** as the OpenXR runtime. In the headset, in Virtual Desktop's Streaming settings, + set the frame rate to **120** (the game then runs at 60 frames a second, as on the console). +4. **Connect the DualSense to the PC**, by USB cable or by Bluetooth paired with the PC, not + with the headset: paired with the headset, it reaches the PC without motion sensors or + touchpad. With no gamepad on the PC, the Touch controllers play instead. +5. **Connect to the PC with Virtual Desktop**, then start **`Play Astro Bot VR.bat`** on the + desktop you see in the headset. A small window lets you choose each eye's resolution, the + frame rate and the field of view; Play starts the game, and the headset switches to it + after a few seconds. + +For the controller to be placed by your hands, turn on hand tracking in the headset and let +Virtual Desktop forward tracking data to the PC. The Touch controller layout, all settings and +what to do when something does not work are in [README-PC-VR.md](README-PC-VR.md). + +## Building from source + +Clone with the submodules: + +```sh +git clone --recurse-submodules https://github.com/bigmak94/AstroQuest.git +``` + +Everything builds on Windows from Git Bash, without admin rights, with a portable toolchain +kept in `tools/` (not in the repository): LLVM/clang 21 (`tools/llvm`), CMake 4.4 +(`tools/cmake`), Ninja (`tools/ninja`) and the MSVC CRT and Windows SDK fetched with +[xwin](https://github.com/Jake-Shadle/xwin) (`tools/winsdk`). + +- **PC build**: `source tools/env-win.sh && cmake --build build/win-x64 --target shadps4`, then + `bash tools/make-pc-vr.sh` puts it in `pc-vr/`. +- **Quest app**: `bash tools/build-arm64.sh` cross-compiles the emulator for the headset + (Debian 13 arm64 sysroot made by `tools/mk-sysroot.mjs`, FEXCore built by the upstream + `shadps4-arm64-main/runtime/scripts/build-fexcore-smoke-aarch64.sh`), then + `bash quest-host/build.sh` builds the APK. That needs the Android SDK (build-tools 36.1, + platform 36), an NDK, a JDK, the + [Khronos OpenXR loader for Android 1.1.63](https://repo1.maven.org/maven2/org/khronos/openxr/openxr_loader_for_android/1.1.63/) + (the `.aar` unzipped into `tools/openxr`), and the + [Bachata S4 v0.2.4](https://github.com/JICA98/Bachata-S4/releases/tag/v0.2.4) release APK + (`bachatas4-0.2.4-release.apk`, SHA-256 `4077b0d0b80e354c71eff1ce2c003f122449ac266eb27a6ac26744d3f9809a08`) + in the top folder, whose Linux runtime (glibc, its libraries and the Turnip Vulkan driver) + the app carries. +- `bash tools/make-release.sh <version>` packs the release files into `build/release/`. + +How it all works, and the tools used to test it on the headset and with a simulated one, is +described in [README-QUEST-VR.md](README-QUEST-VR.md) and [README-PC-VR.md](README-PC-VR.md). + +## Support the project + +If AstroQuest gave you a good time in VR and you want to help it go further, you can support +its development here: + +[![Support AstroQuest](https://img.shields.io/badge/Support-AstroQuest-635BFF?style=for-the-badge&logo=stripe&logoColor=white)](https://buy.stripe.com/6oU4gB5450PZ18h8aK1wY00) + +**https://buy.stripe.com/6oU4gB5450PZ18h8aK1wY00** + +## License + +AstroQuest is free software, licensed under the +[GNU General Public License, version 2 or (at your option) any later version](LICENSE) +(GPL-2.0-or-later), the license of shadPS4 it is built on. + +The third-party components it uses or ships keep their own licenses: among them FEX (MIT), +Mesa's Turnip Vulkan driver (MIT), the GNU C Library (LGPL-2.1-or-later), the Khronos OpenXR +SDK (Apache-2.0) and the libraries under `shadps4-arm64-main/externals`. See +[THIRD-PARTY-NOTICES.md](THIRD-PARTY-NOTICES.md) for what the release files contain and where +the source of each part is. + +ASTRO BOT, PlayStation and PlayStation VR are trademarks of Sony Interactive Entertainment. +This project is not affiliated with, endorsed or sponsored by Sony Interactive Entertainment, +Team Asobi or Meta. It contains no game, firmware, keys or other copyrighted console files: +use it only with software you own and have dumped yourself. + +## Thanks + +- **The [shadPS4](https://github.com/shadps4-emu/shadPS4) team and contributors.** None of + this would exist without their PlayStation 4 emulator: everything here is built on top of + their years of work. Thank you! +- [zenithblue-oss/shadps4-arm64](https://github.com/zenithblue-oss/shadps4-arm64) and + [Bachata S4](https://github.com/JICA98/Bachata-S4), for the ARM64 build of shadPS4, its FEX + integration and the Linux runtime it runs in on Android. +- [FEX-Emu](https://github.com/FEX-Emu/FEX), which runs the game's x86-64 code on the + headset's ARM processor. +- [Mesa](https://www.mesa3d.org/) and its Turnip driver for Adreno GPUs (the build used here + comes from [Vauzi-17/mesa-tu8](https://github.com/Vauzi-17/mesa-tu8)). +- [The Khronos Group](https://www.khronos.org/) for OpenXR and Vulkan, + [vgmstream](https://github.com/vgmstream/vgmstream) for documenting Sony's audio formats, + and [Virtual Desktop](https://www.vrdesktop.net/) for the PC streaming path. diff --git a/THIRD-PARTY-NOTICES.md b/THIRD-PARTY-NOTICES.md new file mode 100644 index 0000000..4767fd7 --- /dev/null +++ b/THIRD-PARTY-NOTICES.md @@ -0,0 +1,54 @@ +# Third-party notices + +AstroQuest itself is licensed under GPL-2.0-or-later (see [LICENSE](LICENSE)). The release files +also contain, or are built with, the following parts made by others. Each keeps its own license; +the source of every part is listed with it. + +## Quest app (`AstroQuest-<version>-Quest3.apk`) + +| Part | License | Source | +| --- | --- | --- | +| The emulator (`shadps4-arm64-fex` in `assets/runtime.zip`): shadPS4 with the shadps4-arm64 changes and this project's | GPL-2.0-or-later | this repository, `shadps4-arm64-main/` (from [zenithblue-oss/shadps4-arm64](https://github.com/zenithblue-oss/shadps4-arm64), based on [shadPS4](https://github.com/shadps4-emu/shadPS4)) | +| The libraries built into the emulator (`shadps4-arm64-main/externals`: SDL3, fmt, Boost, glslang, sirit, Vulkan Memory Allocator, zlib-ng, xxHash, FFmpeg's core and others) | their own licenses (zlib, MIT, BSL-1.0, BSD, LGPL...), in each folder | the submodules listed in [.gitmodules](.gitmodules) | +| FEXCore, linked into the emulator | MIT | [FEX-Emu/FEX](https://github.com/FEX-Emu/FEX), fetched and patched by `shadps4-arm64-main/runtime/scripts/build-fexcore-smoke-aarch64.sh` | +| The app (`libastrovr.so`, `classes.dex`) and `libkgsl_compat.so` | GPL-2.0-or-later | this repository, `quest-host/` | +| LLVM libc++, linked into `libastrovr.so` | Apache-2.0 WITH LLVM-exception | [Android NDK](https://developer.android.com/ndk) / [LLVM](https://github.com/llvm/llvm-project) | +| Khronos OpenXR loader for Android 1.1.63 (`libopenxr_loader.so`) | Apache-2.0 | [KhronosGroup/OpenXR-SDK-Source](https://github.com/KhronosGroup/OpenXR-SDK-Source), release 1.1.63 | +| The GNU C Library 2.41 and its dynamic loader (`libc.so.6`, `libm`, `libdl`, `libpthread`, `librt`, `libresolv`, `libutil`, `ld-linux-aarch64.so.1`, the latter shipped as `libastro_ld.so`) | LGPL-2.1-or-later | Debian 13 `glibc` source package, with the Android compatibility patches in `shadps4-arm64-main/runtime/patches/glibc-android-sysvshm/` and `runtime/scripts/glibc-android-seccomp.mjs` | +| GCC runtime (`libstdc++.so.6`, `libgcc_s.so.1`) | GPL-3.0-or-later WITH GCC-exception-3.1 | Debian 13 `gcc-14` source package | +| X11 and XCB client libraries, libxkbcommon, libxshmfence, libdrm, libexpat, libffi, libwayland-client | MIT / X11 | Debian 13 source packages of the same names | +| libsystemd, libudev | LGPL-2.1-or-later | Debian 13 `systemd` source package | +| libdbus-1 | AFL-2.1 or GPL-2.0-or-later | Debian 13 `dbus` source package | +| libcap | BSD-3-Clause or GPL-2.0-only | Debian 13 `libcap2` source package | +| libuuid | BSD-3-Clause | Debian 13 `util-linux` source package | +| zlib | Zlib | Debian 13 `zlib` source package | +| Vulkan loader (`libvulkan.so.1`), SPIRV-Tools | Apache-2.0 | [KhronosGroup/Vulkan-Loader](https://github.com/KhronosGroup/Vulkan-Loader), [KhronosGroup/SPIRV-Tools](https://github.com/KhronosGroup/SPIRV-Tools), as packaged by Debian 13 | +| Mesa Turnip Vulkan driver for Adreno (`libvulkan_freedreno.so`) | MIT | [Vauzi-17/mesa-tu8](https://github.com/Vauzi-17/mesa-tu8), branch `gen8`, commit `9e646d59830fa220fff9a94ef2ed4a6ce418e254`, with Bachata S4's `kgsl-zero-timeout-poll` patch | + +The Linux runtime (everything from glibc to the Turnip driver above) is taken unchanged from +the [Bachata S4 v0.2.4](https://github.com/JICA98/Bachata-S4/releases/tag/v0.2.4) release, +whose notice (`shadps4-arm64-main/NOTICE.android-runtime.md`) and lock files +(`shadps4-arm64-main/runtime/locks/`) record the exact packages. + +## PC build (`AstroQuest-<version>-PC-VR-Windows.zip`) + +| Part | License | Source | +| --- | --- | --- | +| The emulator (`shadps4.exe`) and the launcher (`launch.ps1`, `Play Astro Bot VR.bat`) | GPL-2.0-or-later | this repository | +| The libraries built into the emulator (`shadps4-arm64-main/externals`) | their own licenses, in each folder | the submodules listed in [.gitmodules](.gitmodules) | +| Khronos OpenXR loader 1.1.63, built into the emulator | Apache-2.0 | `shadps4-arm64-main/externals/openxr-sdk` ([KhronosGroup/OpenXR-SDK](https://github.com/KhronosGroup/OpenXR-SDK), release 1.1.63) | + +The emulator needs the Microsoft Visual C++ runtime, which is not included: it comes with the +[Visual C++ Redistributable](https://aka.ms/vs/17/release/vc_redist.x64.exe). + +## Source of the GPL and LGPL parts + +The source of AstroQuest itself is this repository, at the tag of each release. For the GPL +and LGPL parts made by others (the Linux runtime in the Quest app, and the libraries built into +the emulators from `shadps4-arm64-main/externals`), a copy of the exact source used is +available on request for three years from each release: open an issue on this repository. + +## Not included + +No part of ASTRO BOT Rescue Mission, of the PlayStation 4 system software, or any key or other +copyrighted console file is part of this repository or of its releases. diff --git a/pc-vr/launch.ps1 b/pc-vr/launch.ps1 new file mode 100644 index 0000000..b48854c --- /dev/null +++ b/pc-vr/launch.ps1 @@ -0,0 +1,376 @@ +# Starts ASTRO BOT Rescue Mission in the emulator for a headset connected to this PC (Virtual +# Desktop, or anything else with an OpenXR runtime), and tells what is going on while it runs. +# Started by "Play Astro Bot VR.bat"; settings are in settings.txt next to this file, and the +# main ones can be chosen in a small window before the game starts. +param([string]$SettingsFile = "", [switch]$NoMenu) + +$ErrorActionPreference = "Continue" +$here = Split-Path -Parent $MyInvocation.MyCommand.Path +$root = Split-Path -Parent $here +Set-Location $here +if ($SettingsFile -eq "") { $SettingsFile = Join-Path $here "settings.txt" } + +function Say([string]$text, [string]$color = "Gray") { Write-Host $text -ForegroundColor $color } + +# --- settings ------------------------------------------------------------------------------- +function Read-Settings { + $script:settings = [ordered]@{} + $script:extraEnv = @() + if (Test-Path $SettingsFile) { + foreach ($line in Get-Content $SettingsFile) { + $line = $line.Trim() + if ($line -eq "" -or $line.StartsWith("#")) { continue } + $at = $line.IndexOf("=") + if ($at -lt 1) { continue } + $key = $line.Substring(0, $at).Trim().ToLower() + $value = $line.Substring($at + 1).Trim() + if ($key -eq "env") { $script:extraEnv += $value } else { $script:settings[$key] = $value } + } + } +} +function Setting([string]$key, [string]$default = "") { + if ($settings.Contains($key)) { return $settings[$key] } + return $default +} +# Writes key=value into the settings file: in place of the line that sets it, or at the end. +function Save-Setting([string]$key, [string]$value) { + $lines = @() + if (Test-Path $SettingsFile) { $lines = @(Get-Content $SettingsFile) } + $done = $false + for ($i = 0; $i -lt $lines.Count; $i++) { + if ($lines[$i] -match ("^\s*" + [regex]::Escape($key) + "\s*=")) { + $lines[$i] = "$key=$value" + $done = $true + } + } + if (-not $done) { $lines += "$key=$value" } + Set-Content -Path $SettingsFile -Value $lines -Encoding UTF8 +} +Read-Settings + +# The sizes an eye can be drawn at: the console's largest (1440x1536, what a PlayStation 4 Pro +# draws) and larger, all the same shape. +$widths = @(1440, 1800, 2160, 2520, 2880, 3240, 3600) +function EyeHeight([int]$width) { return [int]([math]::Round(1536.0 * $width / 1440 / 8) * 8) } +$caps = @(120, 90, 72, 60, 45, 40, 36, 30) + +# --- the window ------------------------------------------------------------------------------- +function Show-Menu { + Add-Type -AssemblyName System.Windows.Forms + Add-Type -AssemblyName System.Drawing + [System.Windows.Forms.Application]::EnableVisualStyles() + + $form = New-Object System.Windows.Forms.Form + $form.Text = "Astro Bot VR" + $form.ClientSize = New-Object System.Drawing.Size(560, 452) + $form.StartPosition = "CenterScreen" + $form.FormBorderStyle = "FixedDialog" + $form.MaximizeBox = $false + $form.MinimizeBox = $false + $form.TopMost = $true + $form.Font = New-Object System.Drawing.Font("Segoe UI", 9.5) + + $y = 14 + $title = New-Object System.Windows.Forms.Label + $title.Text = "ASTRO BOT Rescue Mission - PC VR" + $title.Font = New-Object System.Drawing.Font("Segoe UI", 12, [System.Drawing.FontStyle]::Bold) + $title.SetBounds(16, $y, 520, 26) + $form.Controls.Add($title) + $y += 40 + + # Resolution. + $label = New-Object System.Windows.Forms.Label + $label.Text = "Resolution of each eye" + $label.Font = New-Object System.Drawing.Font("Segoe UI", 9.5, [System.Drawing.FontStyle]::Bold) + $label.SetBounds(16, $y, 520, 20) + $form.Controls.Add($label) + $y += 22 + $resolution = New-Object System.Windows.Forms.TrackBar + $resolution.Minimum = 0 + $resolution.Maximum = $widths.Count - 1 + $resolution.TickFrequency = 1 + $resolution.LargeChange = 1 + $resolution.SetBounds(12, $y, 530, 40) + $current = [int](Setting "resolution" "2880") + $index = [array]::IndexOf($widths, $current) + if ($index -lt 0) { $index = 4 } + $resolution.Value = $index + $form.Controls.Add($resolution) + $y += 42 + $resolutionText = New-Object System.Windows.Forms.Label + $resolutionText.SetBounds(16, $y, 530, 38) + $form.Controls.Add($resolutionText) + $update = { + $w = $widths[$resolution.Value] + $h = EyeHeight $w + $times = ($w * $h) / (1440.0 * 1536.0) + $what = if ($w -eq 1440) { "the console's own, as a PlayStation 4 Pro draws it" } else { "{0:N2} times the pixels of the console" -f $times } + $resolutionText.Text = "$w x $h pixels an eye: $what. The game draws smaller by itself when the graphics card cannot keep up." + } + $resolution.Add_ValueChanged($update) + & $update + $y += 46 + + # Frame rate. + $label = New-Object System.Windows.Forms.Label + $label.Text = "Frames a second, at most" + $label.Font = New-Object System.Drawing.Font("Segoe UI", 9.5, [System.Drawing.FontStyle]::Bold) + $label.SetBounds(16, $y, 520, 20) + $form.Controls.Add($label) + $y += 24 + $fps = New-Object System.Windows.Forms.ComboBox + $fps.DropDownStyle = "DropDownList" + foreach ($cap in $caps) { + $text = "$cap" + if ($cap -eq 60) { $text = "60 (the console's own)" } + [void]$fps.Items.Add($text) + } + $fps.SetBounds(16, $y, 200, 26) + $index = [array]::IndexOf($caps, [int](Setting "fps" "60")) + if ($index -lt 0) { $index = 3 } + $fps.SelectedIndex = $index + $form.Controls.Add($fps) + $y += 32 + $fpsText = New-Object System.Windows.Forms.Label + $fpsText.Text = "A frame lasts a whole number of the headset's refreshes, so the headset's refresh rate decides what is possible: at 120 Hz 120, 60, 40 or 30 frames a second, at 90 Hz 90, 45 or 30, at 72 Hz 72 or 36. Virtual Desktop sets the refresh rate (Settings > Streaming > Frame rate): choose 120 for 60 frames a second." + $fpsText.SetBounds(16, $y, 530, 84) + $form.Controls.Add($fpsText) + $y += 88 + + # Field of view. + $label = New-Object System.Windows.Forms.Label + $label.Text = "Field of view" + $label.Font = New-Object System.Drawing.Font("Segoe UI", 9.5, [System.Drawing.FontStyle]::Bold) + $label.SetBounds(16, $y, 520, 20) + $form.Controls.Add($label) + $y += 22 + $fov = New-Object System.Windows.Forms.TrackBar + $fov.Minimum = 14 + $fov.Maximum = 20 + $fov.TickFrequency = 1 + $fov.LargeChange = 1 + $fov.SetBounds(12, $y, 300, 40) + $fov.Value = [math]::Max(14, [math]::Min(20, [int]([int](Setting "fov" "100") / 5))) + $form.Controls.Add($fov) + $fovText = New-Object System.Windows.Forms.Label + $fovText.SetBounds(316, $y + 4, 230, 40) + $form.Controls.Add($fovText) + $ofPsvr = (Setting "fov_of" "headset") -eq "psvr" + $updateFov = { + $percent = $fov.Value * 5 + if ($percent -eq 100) { + $fovText.Text = $(if ($ofPsvr) { "100%: PlayStation VR's own" } else { "100%: all that the headset shows" }) + } else { + $fovText.Text = "$percent% of it: sharper, with a dark border" + } + } + $fov.Add_ValueChanged($updateFov) + & $updateFov + $y += 46 + + $again = New-Object System.Windows.Forms.CheckBox + $again.Text = "Show this window at every start" + $again.Checked = (Setting "menu" "1") -ne "0" + $again.SetBounds(16, $y, 300, 24) + $form.Controls.Add($again) + + $play = New-Object System.Windows.Forms.Button + $play.Text = "Play" + $play.SetBounds(360, $y - 2, 88, 30) + $play.DialogResult = [System.Windows.Forms.DialogResult]::OK + $form.Controls.Add($play) + $form.AcceptButton = $play + $quit = New-Object System.Windows.Forms.Button + $quit.Text = "Quit" + $quit.SetBounds(456, $y - 2, 88, 30) + $quit.DialogResult = [System.Windows.Forms.DialogResult]::Cancel + $form.Controls.Add($quit) + $form.CancelButton = $quit + + $result = $form.ShowDialog() + if ($result -ne [System.Windows.Forms.DialogResult]::OK) { return $false } + Save-Setting "resolution" ($widths[$resolution.Value]) + Save-Setting "fps" ($caps[$fps.SelectedIndex]) + Save-Setting "fov" ($fov.Value * 5) + Save-Setting "menu" ($(if ($again.Checked) { "1" } else { "0" })) + Read-Settings + return $true +} + +if (-not $NoMenu -and (Setting "menu" "1") -ne "0") { + if (-not (Show-Menu)) { exit 0 } +} + +$game = Setting "game" (Join-Path $root "games\CUSA12392\eboot.bin") +if (-not (Test-Path $game)) { + Say "The game was not found at $game" "Red" + Say "Put the extracted game there, or name its eboot.bin with game=... in settings.txt." + Read-Host "Press Enter to close" + exit 1 +} +$emulator = Join-Path $here "shadps4.exe" +if (-not (Test-Path $emulator)) { + Say "shadps4.exe is missing from $here (run tools/make-pc-vr.sh)" "Red" + Read-Host "Press Enter to close" + exit 1 +} + +# What the settings mean to the emulator. +# resolution: the width of an eye (1440 the console's; larger ones are the game's sizes grown, +# with the memory that takes). game: the console's sizes, chosen by the game itself. +$resolution = Setting "resolution" "2880" +$dynamic = (Setting "dynamic" "1") -ne "0" +if ($resolution -eq "game") { + $env:SHADPS4_TITLE_RESOLUTION = "title" +} else { + $width = 0 + if (-not [int]::TryParse($resolution, [ref]$width)) { $width = 2880 } + # (The console's other sizes, 816 to 1200, as they were offered before.) + $smaller = @{ 816 = "3"; 960 = "4"; 1200 = "5" } + if ($smaller.ContainsKey($width)) { + $env:SHADPS4_TITLE_RESOLUTION = $smaller[$width] + } else { + $width = [math]::Max(1440, [math]::Min(4320, [int]([math]::Round($width / 8) * 8))) + if ($width -gt 1440) { $env:SHADPS4_TITLE_EYE_WIDTH = "$width" } + # Left to choose, the emulator draws smaller where the graphics card falls behind. + if (-not $dynamic) { $env:SHADPS4_TITLE_RESOLUTION = "6" } + } +} +$env:SHADPS4_VR_SHARPEN = Setting "sharpen" "0.3" +if ((Setting "msaa") -ne "") { $env:SHADPS4_MAX_MSAA = Setting "msaa" } +if ((Setting "antialias" "1") -eq "0") { $env:SHADPS4_RESOLVE_AA = "0" } +if ((Setting "hands" "1") -eq "0") { $env:SHADPS4_XR_HANDS = "0" } +if ((Setting "predict_ms") -ne "") { $env:SHADPS4_XR_PREDICT_MS = Setting "predict_ms" } +if ((Setting "stick_touchpad" "1") -eq "0") { $env:SHADPS4_STICK_TOUCHPAD = "0" } +if ((Setting "surround" "1") -eq "0") { $env:SHADPS4_VIRTUAL_SURROUND = "0" } +if ((Setting "real_time" "1") -eq "0") { $env:SHADPS4_TITLE_TIMESTEP = "0" } +$fovSetting = Setting "fov" "100" +if ($fovSetting -ne "100") { $env:SHADPS4_VR_FOV = $fovSetting } +# fov_of: what fov is a percent of. headset: what the headset being worn shows, all of it at 100 +# (the emulator asks the headset as it starts). psvr: a PlayStation VR's, as the game was made. +if ((Setting "fov_of" "headset") -ne "psvr") { $env:SHADPS4_VR_FOV_OF = "headset" } +# fps: the most frames a second. (pace, the older way to say it: refreshes of the headset a +# frame is given, 1 or more.) +$env:SHADPS4_VR_FPS_CAP = Setting "fps" "60" +$pace = Setting "pace" "" +if ($pace -eq "1") { $env:SHADPS4_VR_FASTEST_PACE = "1"; $env:SHADPS4_VR_FPS_CAP = "" } elseif ($pace -ne "" -and $pace -ne "2") { $env:SHADPS4_VR_PACE = $pace } +if ((Setting "headset" "1") -eq "0") { $env:SHADPS4_OPENXR = "0" } +if ((Setting "pause" "1") -eq "0") { $env:SHADPS4_XR_PAUSE = "0" } +if ((Setting "controllers" "1") -eq "0") { $env:SHADPS4_XR_CONTROLLERS = "0" } +if ((Setting "controller_hand" "right") -eq "left") { $env:SHADPS4_XR_PAD_HAND = "left" } +$env:SHADPS4_XR_WAIT = Setting "wait" "60" +foreach ($pair in $extraEnv) { + $at = $pair.IndexOf("=") + if ($at -ge 1) { Set-Item -Path ("Env:" + $pair.Substring(0, $at)) -Value $pair.Substring($at + 1) } +} + +# --- what is there ---------------------------------------------------------------------------- +Say "ASTRO BOT Rescue Mission - PC VR" "Cyan" +if ($env:SHADPS4_TITLE_EYE_WIDTH) { + Say ("Each eye up to " + $env:SHADPS4_TITLE_EYE_WIDTH + " x " + (EyeHeight ([int]$env:SHADPS4_TITLE_EYE_WIDTH)) + ", at most " + $env:SHADPS4_VR_FPS_CAP + " frames a second.") +} +$runtime = "" +if ($env:XR_RUNTIME_JSON) { + $runtime = $env:XR_RUNTIME_JSON +} else { + try { $runtime = (Get-ItemProperty 'HKLM:\SOFTWARE\Khronos\OpenXR\1' -ErrorAction Stop).ActiveRuntime } catch {} +} +if ($runtime -eq "") { + Say "No OpenXR runtime is set up on this PC: the game will only show on the monitor." "Yellow" + Say "Virtual Desktop Streamer installs one (Options > OpenXR Runtime: VDXR)." +} else { + Say "OpenXR runtime: $runtime" + if ($runtime -match "virtualdesktop") { + $streamer = Get-Process "VirtualDesktop.Streamer" -ErrorAction SilentlyContinue + if (-not $streamer) { + $exe = Join-Path (Split-Path -Parent (Split-Path -Parent $runtime)) "VirtualDesktop.Streamer.exe" + if (Test-Path $exe) { + Say "Starting Virtual Desktop Streamer..." + Start-Process $exe + } else { + Say "Virtual Desktop Streamer is not running: start it, then connect from the headset." "Yellow" + } + } + } +} +Say "" +Say "In the headset: connect Virtual Desktop to this PC. The game moves into the headset by itself." +if ($env:SHADPS4_OPENXR -ne "0" -and [int]$env:SHADPS4_XR_WAIT -gt 0) { + Say ("The game waits up to " + $env:SHADPS4_XR_WAIT + " seconds for the headset before it starts on the monitor.") +} +Say "The DualSense: connect it to THIS PC (USB cable, or Bluetooth paired with the PC). Paired with" +Say "the headset, it reaches the PC through Virtual Desktop without motion sensors or touchpad." +Say "Where it is in the game comes from your hands: hand tracking on in the headset, and in" +Say "Virtual Desktop's settings hand tracking forwarded to the PC." +Say "Hold OPTIONS for a second (or press the PS button) to reset the view." +Say "No gamepad: the headset's own controllers play (A jump, B punch, right stick = touchpad," +Say "press both sticks in to reset the view)." +Say "Close the game's window to quit." +Say "" + +# --- run -------------------------------------------------------------------------------------- +$logDir = Join-Path $here "user\log" +$log = Join-Path $logDir "shad_log.txt" +New-Item -ItemType Directory -Force -Path $logDir | Out-Null +if (Test-Path $log) { Copy-Item $log (Join-Path $logDir "shad_log.prev.txt") -Force } + +# (In this console, with what it prints kept out of the way: a window style given here would +# also be the game window's.) +$process = Start-Process -FilePath $emulator -ArgumentList @("-g", "`"$game`"") -WorkingDirectory $here ` + -PassThru -NoNewWindow -RedirectStandardOutput (Join-Path $logDir "console.txt") ` + -RedirectStandardError (Join-Path $logDir "console-errors.txt") +# (Without this the exit code is not to be had later.) +$null = $process.Handle +$position = 0 +$shown = @{} +function Show-Log { + if (-not (Test-Path $log)) { return } + try { + $stream = [System.IO.File]::Open($log, 'Open', 'Read', 'ReadWrite') + } catch { return } + try { + if ($stream.Length -lt $script:position) { $script:position = 0 } + [void]$stream.Seek($script:position, 'Begin') + $reader = New-Object System.IO.StreamReader($stream) + while ($true) { + $line = $reader.ReadLine() + if ($null -eq $line) { break } + if ($line -match '^\[Core\.Vr\] <(Info|Warning)> \([^)]*\) \S+ (?:\w+: )?(.*)$') { + $warning = $Matches[1] -eq "Warning" + $text = $Matches[2] + # The lines that repeat every few seconds only once in a while. + if ($text -match '^(The title (has|now takes) the player|Hands:|Virtual headset connected)') { continue } + if ($text -match '^Headset: the title delivered') { + $script:reports++ + if (($script:reports % 6) -ne 1) { continue } + } + if ($text -match '^Controllers: standing in') { + if (($script:reports % 6) -ne 1) { continue } + } + if ($warning) { Say (" " + $text) "Yellow" } else { Say (" " + $text) } + } elseif ($line -match '^\[Input\] <Info> \([^)]*\) \S+ (?:\w+: )?(Controller .*)$') { + Say (" " + $Matches[1]) + } elseif ($line -match '^\[Core\] <Info> \([^)]*\) \S+ (?:\w+: )?(The title draws at up to .*|The scene is drawn at .*|Frames are given .*)$') { + Say (" " + $Matches[1]) + } elseif ($line -match '<Critical>.*?: (.*)$') { + $text = $Matches[1] + if (-not $shown.ContainsKey($text)) { $shown[$text] = 1; Say (" ! " + $text) "Red" } + } + } + $script:position = $stream.Position + } finally { $stream.Dispose() } +} +$reports = 0 +while (-not $process.HasExited) { + Start-Sleep -Milliseconds 700 + Show-Log +} +Show-Log +Say "" +if ($null -ne $process.ExitCode -and $process.ExitCode -ne 0) { + Say ("The emulator ended with code " + $process.ExitCode + ". Its log is $log") "Yellow" + Read-Host "Press Enter to close" +} else { + Say "The game was closed." + Start-Sleep -Seconds 2 +} diff --git a/pc-vr/settings.txt b/pc-vr/settings.txt new file mode 100644 index 0000000..ca1981a --- /dev/null +++ b/pc-vr/settings.txt @@ -0,0 +1,100 @@ +# Settings for "Play Astro Bot VR.bat", one key=value a line. Lines starting with # are ignored; +# what is commented out below shows the value that applies when the line is left out. + +# The window at the start (menu=0 to go without it) sets resolution, fps and fov below. + +# The width of each eye's picture: 1440 is the console's largest (what a PlayStation 4 Pro +# draws, 1440x1536); 1800, 2160, 2520, 2880, 3240 or 3600 have the game draw that much larger +# (2880 = 2880x3072, four times the pixels), with the memory that takes. The game draws a step +# smaller by itself while the graphics card cannot keep up; dynamic=0 holds it to the size. +# game: the console's sizes, chosen by the game itself (816 to 1440). +#resolution=2880 +#dynamic=1 + +# The most frames a second: 120, 90, 72, 60, 45, 40, 36 or 30. A frame lasts a whole number of +# the headset's refreshes, so the refresh rate set in Virtual Desktop (Streaming > Frame rate) +# decides what is possible: at 120 Hz 120, 60, 40 or 30; at 90 Hz 90, 45 or 30; at 72 Hz 72 or +# 36. 60 is the console's own. Above 60 the PC has to keep up (this one manages about 100), and +# the few things the game counts in frames (some animated signs) run faster. +#fps=60 + +# How much of the headset's field of view the game draws, in percent, 70 to 100: at 100 the +# picture fills all that the headset shows; less puts the same pixels over fewer degrees, a +# sharper picture with a dark border where the rest was. +#fov=100 + +# What fov is a percent of: headset (the headset being worn, whatever it is: the emulator asks +# it as the game starts) or psvr (a PlayStation VR's 100 by 103 degrees an eye, the view the +# game was made for, which leaves a narrow dark margin far out to the sides on a Quest 3). +#fov_of=headset + +# 1: the window with the main settings comes up at every start. +#menu=1 + +# Sharpening of the picture on its way to the headset, 0 (none) to 1. Virtual Desktop has a +# sharpening of its own (Streaming tab): what is here comes on top of it. +#sharpen=0.3 + +# The most samples a pixel gets (1, 2, 4, 8). Left out: as the console draws it (4). With 1 the +# emulator smooths edges itself instead, unless antialias=0. +#msaa=4 +#antialias=1 + +# 0: your hands are not used to place the controller in the game; it then stays at a fixed +# spot in front of you, turned by its own motion sensors. (The hands are what the headset +# tracks: hand tracking has to be on in the headset, and Virtual Desktop has to pass it on to +# the PC - its setting for forwarding tracking data. Where it does not, the places it gives +# the headset's controllers stand in, which it makes up from the hands while they lie unused.) +# The DualSense must be connected to this PC itself (USB cable or Bluetooth): paired with the +# headset, it reaches the PC through Virtual Desktop without motion sensors and touchpad. +#hands=1 + +# How far beyond the next picture the head position given to the game is predicted, in +# milliseconds (0 to 80). More if black edges show when you turn your head, less if the world +# wobbles. +#predict_ms=20 + +# 0: the right stick no longer doubles as a finger on the touchpad. +#stick_touchpad=1 + +# 0: the headset's own controllers never stand in for a gamepad. (They only do while no gamepad +# is connected to the PC.) +#controllers=1 + +# Which of the headset's controllers is the controller in the game while they stand in for a +# gamepad: right or left. +#controller_hand=right + +# 0: the game's surround sound is folded down to left and right instead of being rendered for +# the headset's speakers. +#surround=1 + +# 0: the game is never made to wait. (It waits, black, while the headset is off the head or +# shows something else, Virtual Desktop's view of the desktop for one, and goes on after.) For +# when it waits although the headset is on and shows the game. +#pause=1 + +# 0: the game counts time in frames, as on the console (slow motion whenever a frame takes +# longer than a sixtieth of a second). +#real_time=1 + +# The older way to say fps: how many of the headset's pictures every frame is given (1, 2, 3...). +# Takes the place of fps when set. +#pace=2 + +# Seconds to wait for a headset before the game starts on the monitor without one. A headset +# connected later is picked up anyway, wherever the game is by then. 0: do not wait. +#wait=60 + +# 0: do not look for a headset at all, play on the monitor. +#headset=1 + +# Where the game is, if not in games\CUSA12392 next to this folder. +#game=C:\path\to\CUSA12392\eboot.bin + +# Extra environment variables for the emulator, as many lines as needed. +#env=NAME=value +resolution=2880 +fps=60 +fov=100 +menu=1 diff --git a/quest-host/AndroidManifest.xml b/quest-host/AndroidManifest.xml new file mode 100644 index 0000000..1914778 --- /dev/null +++ b/quest-host/AndroidManifest.xml @@ -0,0 +1,96 @@ +<?xml version="1.0" encoding="utf-8"?> +<!-- + Immersive OpenXR host for the shadPS4 ARM64 core on Meta Quest. The manifest follows Meta's + "Android Manifest Settings" page for native apps (activity attributes, VR intent category, + head-tracking feature, supported devices) plus what the Khronos OpenXR loader needs to find + the runtime (permissions and queries, copied from openxr_loader_for_android's own manifest). +--> +<manifest xmlns:android="http://schemas.android.com/apk/res/android" + package="com.astrobotquest.vrhost" + android:versionCode="11" + android:versionName="0.11" + android:installLocation="auto"> + + <uses-sdk + android:minSdkVersion="32" + android:targetSdkVersion="32" /> + + <uses-feature + android:name="android.hardware.vr.headtracking" + android:required="true" + android:version="1" /> + <uses-feature + android:glEsVersion="0x00030001" + android:required="true" /> + + <!-- + The game is played with a gamepad. Declaring hand tracking tells Horizon OS that Touch + controllers are not needed; without it the launch is blocked by a "controllers required" + dialog whenever they are asleep. + --> + <uses-permission android:name="com.oculus.permission.HAND_TRACKING" /> + <uses-feature + android:name="oculus.software.handtracking" + android:required="false" /> + + <uses-permission android:name="org.khronos.openxr.permission.OPENXR" /> + <uses-permission android:name="org.khronos.openxr.permission.OPENXR_SYSTEM" /> + <!-- Lets the app see a paired DualSense's rumble motors. --> + <uses-permission android:name="android.permission.VIBRATE" /> + <!-- + The game listens to the headset's microphone (blowing at things in its world), as it did + to PlayStation VR's. Asked for when the app starts; without it the game hears silence. + --> + <uses-permission android:name="android.permission.RECORD_AUDIO" /> + + <!-- Development aid, see SandboxShell.java. --> + <instrumentation + android:name="com.astrobotquest.vrhost.SandboxShell" + android:targetPackage="com.astrobotquest.vrhost" /> + + <queries> + <provider android:authorities="org.khronos.openxr.runtime_broker;org.khronos.openxr.system_runtime_broker" /> + <intent> + <action android:name="org.khronos.openxr.OpenXRRuntimeService" /> + </intent> + <intent> + <action android:name="org.khronos.openxr.OpenXRApiLayerService" /> + </intent> + </queries> + + <!-- + extractNativeLibs: the glibc dynamic loader ships as lib/arm64-v8a/libastro_ld.so and has to + exist as a real file the app may execute. + --> + <application + android:label="@string/app_name" + android:allowBackup="false" + android:extractNativeLibs="true" + android:hasCode="true" + android:appCategory="game"> + + <meta-data + android:name="com.oculus.supportedDevices" + android:value="quest3|quest3s" /> + <!-- The hands are followed to place the controller they hold: as often as possible. --> + <meta-data + android:name="com.oculus.handtracking.frequency" + android:value="HIGH" /> + + <activity + android:name="com.astrobotquest.vrhost.MainActivity" + android:exported="true" + android:screenOrientation="landscape" + android:theme="@android:style/Theme.Black.NoTitleBar.Fullscreen" + android:configChanges="density|keyboard|keyboardHidden|navigation|orientation|screenLayout|screenSize|uiMode" + android:launchMode="singleTask" + android:resizeableActivity="false"> + <intent-filter> + <action android:name="android.intent.action.MAIN" /> + <category android:name="android.intent.category.LAUNCHER" /> + <category android:name="com.oculus.intent.category.VR" /> + <category android:name="org.khronos.openxr.intent.category.IMMERSIVE_HMD" /> + </intent-filter> + </activity> + </application> +</manifest> diff --git a/quest-host/build.sh b/quest-host/build.sh new file mode 100644 index 0000000..92dc31e --- /dev/null +++ b/quest-host/build.sh @@ -0,0 +1,167 @@ +#!/usr/bin/env bash +# Builds the Quest host APK without Gradle or Android Studio projects: +# NDK clang -> libastrovr.so, javac + d8 -> classes.dex, aapt2 -> APK, zipalign + apksigner. +# +# The Linux runtime the emulator core runs in (glibc, its loader, the Turnip Vulkan driver) is +# taken from the user's copy of the Bachata S4 APK at build time, and the core itself from +# build/arm64 (tools/build-arm64.sh). +# +# quest-host/build.sh [--driver <zip inside the APK's assets/drivers>] [--trade-cpu-for-gpu] +# +# --trade-cpu-for-gpu builds the app that gives up one processor clock level (1.92 -> 1.65 GHz +# on a Quest 3) for one more GPU clock level (up to 640 MHz instead of 599). The system only +# takes that choice from the manifest, so it is a build of its own. +set -euo pipefail + +root=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd) +host="$root/quest-host" +out="$root/build/quest" + +NDK=${ANDROID_NDK:-"/c/Program Files/Unity/Hub/Editor/6000.3.2f1/Editor/Data/PlaybackEngines/AndroidPlayer/NDK"} +SDK=${ANDROID_SDK:-"$LOCALAPPDATA/Android/Sdk"} +BUILD_TOOLS="$SDK/build-tools/36.1.0" +PLATFORM_JAR="$SDK/platforms/android-36/android.jar" +JDK=${JAVA_HOME:-"/c/Program Files/Android/Android Studio/jbr"} +# Python: $PYTHON, or the one named in tools/python.local (a full path), or the one on PATH. +PYTHON=${PYTHON:-$(cat "$root/tools/python.local" 2>/dev/null || command -v python3 || command -v python)} +BACHATA_APK="$root/bachatas4-0.2.4-release.apk" +CORE="$root/build/arm64/shadps4" +OPENXR="$root/tools/openxr" +driver="turnip-vauzi-7xx-EMULATOR.zip" +# Source paths in the binaries are counted from this folder, not from the machine's root. +prefix_map="-ffile-prefix-map=$(cygpath -m "$root")/=" + +trade="" +while [[ $# -gt 0 ]]; do + case "$1" in + --driver) driver=$2; shift 2 ;; + --trade-cpu-for-gpu) trade=1; shift ;; + *) echo "unknown option $1" >&2; exit 64 ;; + esac +done + +export JAVA_HOME="$JDK" +export PATH="$JDK/bin:$PATH" +for needed in "$NDK/toolchains/llvm/prebuilt/windows-x86_64/bin/clang++.exe" "$BUILD_TOOLS/aapt2.exe" \ + "$PLATFORM_JAR" "$JDK/bin/javac.exe" "$PYTHON" "$BACHATA_APK" "$CORE" \ + "$OPENXR/jni/arm64-v8a/libopenxr_loader.so" \ + "$root/tools/llvm/bin/aarch64-linux-gnu-clang.exe"; do + [[ -e "$needed" ]] || { echo "missing: $needed" >&2; exit 1; } +done + +rm -rf "$out/apk" "$out/classes" "$out/dex" "$out/runtime" "$out/bachata" +mkdir -p "$out/apk/lib/arm64-v8a" "$out/apk/assets" "$out/classes" "$out/dex" "$out/runtime" "$out/bachata" + +echo "== runtime" +# The glibc world: libraries and the loader (which Android only lets us execute from the +# app's native library folder, hence its lib*.so name). +unzip -q -o "$BACHATA_APK" "assets/runtime/runtime.zip" "assets/drivers/$driver" \ + "lib/arm64-v8a/libbachata_host_loader.so" -d "$out/bachata" +unzip -q -o "$out/bachata/assets/runtime/runtime.zip" "host/*" -d "$out/runtime" +rm -rf "$out/runtime/host/shadps4-arm64-fex" "$out/runtime/host/fexcore-guest-harness" \ + "$out/runtime/host/fexcore-smoke" "$out/runtime/host/lib" "$out/runtime/host/vulkan" +cp "$out/bachata/lib/arm64-v8a/libbachata_host_loader.so" "$out/apk/lib/arm64-v8a/libastro_ld.so" +mkdir -p "$out/runtime/drivers/turnip" +unzip -q -o "$out/bachata/assets/drivers/$driver" -d "$out/runtime/drivers/turnip" +[[ -f "$out/runtime/drivers/turnip/freedreno_icd.aarch64.json" ]] || { + echo "$driver is not a glibc Turnip package (no ICD manifest)" >&2; exit 1; } +"$root/tools/llvm/bin/llvm-strip.exe" -o "$out/runtime/host/shadps4-arm64-fex" "$CORE" +# Translates the GPU memory calls Horizon OS denies to apps into the ones it allows. A glibc +# library like the rest of the runtime, so it is built with the same cross compiler as the core. +"$root/tools/llvm/bin/aarch64-linux-gnu-clang.exe" -O2 -fPIC -shared "$prefix_map" \ + "$(cygpath -m "$host/runtime/kgsl_compat.c")" -lpthread \ + -o "$(cygpath -m "$out/runtime/host/libkgsl_compat.so")" + +"$PYTHON" - "$out/runtime" "$out/apk/assets/runtime.zip" "$out/apk/assets/runtime.stamp" <<'PY' +import hashlib, os, sys, zipfile +source, target, stamp = sys.argv[1:4] +digest = hashlib.sha256() +with zipfile.ZipFile(target, "w", zipfile.ZIP_DEFLATED, compresslevel=6) as archive: + for folder, _, files in sorted(os.walk(source)): + for name in sorted(files): + path = os.path.join(folder, name) + relative = os.path.relpath(path, source).replace(os.sep, "/") + with open(path, "rb") as handle: + data = handle.read() + digest.update(relative.encode() + b"\0" + data) + # A fixed timestamp keeps the archive, and so the stamp, reproducible. + info = zipfile.ZipInfo(relative, (2026, 1, 1, 0, 0, 0)) + info.compress_type = zipfile.ZIP_DEFLATED + info.external_attr = 0o755 << 16 + archive.writestr(info, data) +with open(stamp, "w") as handle: + handle.write(digest.hexdigest() + "\n") +print("runtime.zip", os.path.getsize(target) // (1 << 20), "MB") +PY + +echo "== native" +"$NDK/toolchains/llvm/prebuilt/windows-x86_64/bin/clang++.exe" --target=aarch64-linux-android32 \ + -std=c++20 -O2 -fPIC -fvisibility=hidden "$prefix_map" -Wall -Wextra -Wno-unused-parameter \ + -Wno-missing-field-initializers \ + -I "$(cygpath -m "$OPENXR/prefab/modules/headers/include")" \ + -I "$(cygpath -m "$root/shadps4-arm64-main/src/core/vr")" \ + "$(cygpath -m "$host/cpp/main.cpp")" "$(cygpath -m "$host/cpp/core_process.cpp")" \ + "$(cygpath -m "$host/cpp/xr_host.cpp")" "$(cygpath -m "$host/cpp/gl_frames.cpp")" \ + "$(cygpath -m "$host/cpp/self_test.cpp")" "$(cygpath -m "$host/cpp/log.cpp")" \ + "$(cygpath -m "$host/cpp/xr_probe.cpp")" \ + -shared -static-libstdc++ -Wl,--no-undefined -Wl,-soname,libastrovr.so \ + -L "$(cygpath -m "$OPENXR/jni/arm64-v8a")" -lopenxr_loader \ + -lEGL -lGLESv3 -landroid -lnativewindow -laaudio -llog -lz \ + -o "$(cygpath -m "$out/apk/lib/arm64-v8a/libastrovr.so")" +cp "$OPENXR/jni/arm64-v8a/libopenxr_loader.so" "$out/apk/lib/arm64-v8a/" + +echo "== java" +javac -Xlint:-options -source 11 -target 11 -classpath "$(cygpath -m "$PLATFORM_JAR")" \ + -d "$(cygpath -m "$out/classes")" \ + "$(cygpath -m "$host/java/com/astrobotquest/vrhost/MainActivity.java")" \ + "$(cygpath -m "$host/java/com/astrobotquest/vrhost/SandboxShell.java")" \ + "$(cygpath -m "$host/java/com/astrobotquest/vrhost/RuntimeInstaller.java")" +# d8 is a batch file around a jar; call the jar so paths with spaces survive. +java -cp "$(cygpath -m "$BUILD_TOOLS/lib/d8.jar")" com.android.tools.r8.D8 \ + --lib "$(cygpath -m "$PLATFORM_JAR")" --min-api 32 --output "$(cygpath -m "$out/dex")" \ + $(find "$out/classes" -name "*.class" -exec cygpath -m {} \;) +cp "$out/dex/classes.dex" "$out/apk/classes.dex" + +echo "== package" +manifest="$host/AndroidManifest.xml" +if [[ -n "$trade" ]]; then + # Per Meta's "Trading CPU and GPU levels": 1 = one level more for the GPU, one less for the + # processor. + manifest="$out/AndroidManifest.xml" + sed 's|^\( *\)<activity$|\1<meta-data\n\1 android:name="com.oculus.trade_cpu_for_gpu_amount"\n\1 android:value="1" />\n\n\1<activity|' \ + "$host/AndroidManifest.xml" > "$manifest" + grep -q trade_cpu_for_gpu_amount "$manifest" || { echo "could not add the trade to the manifest" >&2; exit 1; } + echo " with one processor level traded for one GPU level" +fi +"$BUILD_TOOLS/aapt2.exe" compile --dir "$(cygpath -m "$host/res")" -o "$(cygpath -m "$out/res.zip")" +"$BUILD_TOOLS/aapt2.exe" link -o "$(cygpath -m "$out/base.apk")" \ + -I "$(cygpath -m "$PLATFORM_JAR")" --manifest "$(cygpath -m "$manifest")" \ + -A "$(cygpath -m "$out/apk/assets")" --debug-mode \ + --min-sdk-version 32 --target-sdk-version 32 "$(cygpath -m "$out/res.zip")" +"$PYTHON" - "$out/base.apk" "$out/apk" <<'PY' +import os, sys, zipfile +apk, staging = sys.argv[1:3] +with zipfile.ZipFile(apk, "a", zipfile.ZIP_DEFLATED) as archive: + archive.write(os.path.join(staging, "classes.dex"), "classes.dex") + libs = os.path.join(staging, "lib", "arm64-v8a") + for name in sorted(os.listdir(libs)): + archive.write(os.path.join(libs, name), "lib/arm64-v8a/" + name) +PY +"$BUILD_TOOLS/zipalign.exe" -p -f 4 "$(cygpath -m "$out/base.apk")" "$(cygpath -m "$out/aligned.apk")" +# An update only installs over an app signed with the same key. Releases are signed with the +# key named in tools/signing.local (two lines: the keystore, then a file holding its password; +# neither belongs in the repository), other builds with the Android SDK's debug key. +if [[ -f "$root/tools/signing.local" ]]; then + { read -r keystore; read -r password_file; } < <(tr -d '\r' < "$root/tools/signing.local") + # (Its key has the keystore's password: apksigner then needs no --key-pass.) + signing=(--ks "$keystore" --ks-pass "file:$password_file") + echo " signed with $(basename "$keystore")" +else + signing=(--ks "$(cygpath -m "$HOME/.android/debug.keystore")" --ks-pass pass:android + --key-pass pass:android) + echo " signed with the debug key" +fi +java -jar "$(cygpath -m "$BUILD_TOOLS/lib/apksigner.jar")" sign "${signing[@]}" \ + --out "$(cygpath -m "$out/astro-vr-host.apk")" "$(cygpath -m "$out/aligned.apk")" + +ls -la "$out/astro-vr-host.apk" diff --git a/quest-host/cpp/core_process.cpp b/quest-host/cpp/core_process.cpp new file mode 100644 index 0000000..3469940 --- /dev/null +++ b/quest-host/cpp/core_process.cpp @@ -0,0 +1,1155 @@ +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "core_process.h" + +#include <algorithm> +#include <cerrno> +#include <chrono> +#include <cinttypes> +#include <cmath> +#include <cstdio> +#include <cstdlib> +#include <cstring> + +#include <aaudio/AAudio.h> +#include <dirent.h> +#include <fcntl.h> +#include <poll.h> +#include <signal.h> +#include <sys/resource.h> +#include <sys/socket.h> +#include <sys/stat.h> +#include <sys/un.h> +#include <sys/wait.h> +#include <unistd.h> + +#include "log.h" + +namespace Protocol = Core::Vr::Protocol; + +namespace { + +void MakeDirs(const std::string& path) { + for (size_t pos = 1; pos <= path.size(); ++pos) { + if (pos == path.size() || path[pos] == '/') { + ::mkdir(path.substr(0, pos).c_str(), 0700); + } + } +} + +int Listen(const std::string& path, int type) { + sockaddr_un address{}; + address.sun_family = AF_UNIX; + if (path.size() >= sizeof(address.sun_path)) { + LOGE("socket path too long: %s", path.c_str()); + return -1; + } + std::strcpy(address.sun_path, path.c_str()); + ::unlink(path.c_str()); + + const int fd = ::socket(AF_UNIX, type | SOCK_CLOEXEC, 0); + if (fd < 0) { + LOGE("socket(%s): %s", path.c_str(), std::strerror(errno)); + return -1; + } + if (::bind(fd, reinterpret_cast<const sockaddr*>(&address), sizeof(address)) != 0 || + ::listen(fd, 4) != 0) { + LOGE("bind/listen(%s): %s", path.c_str(), std::strerror(errno)); + ::close(fd); + return -1; + } + return fd; +} + +/// Waits for a connection without blocking forever, so the thread can notice a shutdown. +int Accept(int listen_fd, const std::atomic<bool>& quit) { + while (!quit) { + pollfd poll_fd{.fd = listen_fd, .events = POLLIN, .revents = 0}; + const int ready = ::poll(&poll_fd, 1, 200); + if (ready < 0 && errno != EINTR) { + return -1; + } + if (ready > 0) { + const int fd = ::accept4(listen_fd, nullptr, nullptr, SOCK_CLOEXEC); + if (fd >= 0) { + return fd; + } + } + } + return -1; +} + +bool ReadFully(int fd, void* data, size_t size) { + auto* bytes = static_cast<uint8_t*>(data); + while (size > 0) { + const ssize_t count = ::recv(fd, bytes, size, 0); + if (count == 0 || (count < 0 && errno != EINTR)) { + return false; + } + if (count > 0) { + bytes += count; + size -= static_cast<size_t>(count); + } + } + return true; +} + +//// The output stream of one audio port of the guest. +/// +/// Nothing here waits inside the audio system: a write that blocks does so for as long as the +/// output takes, and an output that is suspended (the headset asleep, the route changing) takes +/// for ever. Writes only ever put in what there is room for; the waiting is done here, and it +/// ends. +class AudioOutput { +public: + ~AudioOutput() { + Close(); + } + + void Open(uint32_t sample_rate) { + Close(); + rate = sample_rate; + opened = Clock::now(); + AAudioStreamBuilder* builder = nullptr; + if (AAudio_createStreamBuilder(&builder) != AAUDIO_OK) { + return; + } + AAudioStreamBuilder_setFormat(builder, AAUDIO_FORMAT_PCM_I16); + AAudioStreamBuilder_setChannelCount(builder, 2); + AAudioStreamBuilder_setSampleRate(builder, static_cast<int32_t>(sample_rate)); + AAudioStreamBuilder_setPerformanceMode(builder, AAUDIO_PERFORMANCE_MODE_LOW_LATENCY); + AAudioStreamBuilder_setUsage(builder, AAUDIO_USAGE_GAME); + if (AAudioStreamBuilder_openStream(builder, &stream) != AAUDIO_OK) { + LOGE("unable to open an audio stream at %u Hz", sample_rate); + stream = nullptr; + } else { + static std::atomic<int> streams{0}; + id = ++streams; + // The stream takes sound out of its buffer a "burst" at a time. What waits in the + // buffer is the cushion for an emulator that delivers a few milliseconds at a time + // and is sometimes late; it is also delay. Two bursts are the least that plays + // without gaps at all; a third is what a delay of the emulator may use up before + // it is heard (the emulator makes up for it afterwards and fills the buffer again). + burst = std::max(AAudioStream_getFramesPerBurst(stream), 1); + const int32_t wanted = + std::max(burst * 2, static_cast<int32_t>(sample_rate * 3 / 50)); + const int32_t set = AAudioStream_setBufferSizeInFrames(stream, wanted); + const int32_t size = set > 0 ? set : AAudioStream_getBufferSizeInFrames(stream); + // Room is made a burst at a time: several bursts is as long as a write can take + // while the stream is alive, also when it has to wake the speakers up first. + patience = std::chrono::nanoseconds{std::clamp<int64_t>( + int64_t{burst} * 8'000'000'000LL / sample_rate, 100'000'000, 300'000'000)}; + underruns = 0; + reported_underruns = 0; + stalled = false; + const aaudio_result_t started = AAudioStream_requestStart(stream); + // The system only starts to play a stream once its buffer has been filled to that + // size, the first time and after every longer gap: nothing may be held back from it + // before that, or it stays silent for good. + LOGI("sound %d: stream opened at %u Hz, bursts of %d frames, %d of %d frames of " + "buffer in use (start: %d)", + id, sample_rate, burst, size, AAudioStream_getBufferCapacityInFrames(stream), + static_cast<int>(started)); + } + AAudioStreamBuilder_delete(builder); + reported = Clock::now(); + } + + /// Plays `frames` frames of 16-bit stereo. Taking as long as the sound lasts is what paces + /// the guest's audio thread; a stream that does not play must not hold the game back, + /// though: what it has no room for is then dropped and the emulator keeps time by its own + /// clock. + void Play(const uint8_t* data, int32_t frames) { + if (stream == nullptr) { + // The stream was lost: try for a new one now and then. + if (rate != 0 && Clock::now() - opened > std::chrono::seconds{1}) { + Open(rate); + } + if (stream == nullptr) { + return; + } + } + + // (After running dry the buffer fills up again by itself: the emulator hands over what + // it was late with as fast as there is room for it.) + underruns = AAudioStream_getXRunCount(stream); + + // What fits goes in at once; the rest waits here for the stream to make room, which + // is the wait that keeps the game's sound in step with the speakers. + const auto begun = Clock::now(); + int32_t left = frames; + while (left > 0) { + const aaudio_result_t result = AAudioStream_write(stream, data, left, 0); + if (result < 0) { + // Typically the output device went away (headphones, a route change). + LOGW("sound %d: stream error %d, opening a new one", id, static_cast<int>(result)); + Close(); + return; + } + data += static_cast<size_t>(result) * 4; + left -= result; + if (left == 0 || stalled) { + break; + } + if (Clock::now() - begun >= patience) { + stalled = true; + read_at_stall = AAudioStream_getFramesRead(stream); + if (++stalls <= 5 || stalls % 100 == 0) { + LOGW("sound %d: the stream takes nothing (%s, %lld frames played so far): " + "dropping sound until it does (%d times so far)", + id, AAudio_convertStreamStateToText(AAudioStream_getState(stream)), + static_cast<long long>(read_at_stall), stalls); + } + break; + } + ::usleep(1'000); + } + taken += frames - left; + dropped += left; + // A stream that takes sound out of its buffer again is back. + if (stalled && AAudioStream_getFramesRead(stream) != read_at_stall) { + stalled = false; + if (stalls <= 5 || stalls % 100 == 0) { + LOGI("sound %d: the stream plays again", id); + } + } + Report(); + } + +private: + using Clock = std::chrono::steady_clock; + + /// Every ten seconds: whether what the emulator delivers ends up at the speakers. + void Report() { + const auto now = Clock::now(); + if (now - reported < std::chrono::seconds{10}) { + return; + } + const int64_t written = AAudioStream_getFramesWritten(stream); + const int64_t played = AAudioStream_getFramesRead(stream); + // (The stream counts its dry runs from when it was opened.) + LOGI("sound %d: %.1f s delivered, %.1f s dropped, %.1f s played by the stream in %.1f s; " + "ran dry %d times in that time (%d since it was opened); %lld frames waiting, " + "stream %s", + id, static_cast<double>(taken) / rate, static_cast<double>(dropped) / rate, + static_cast<double>(played - reported_played) / rate, + std::chrono::duration<double>(now - reported).count(), underruns - reported_underruns, + underruns, static_cast<long long>(written - played), + AAudio_convertStreamStateToText(AAudioStream_getState(stream))); + reported_underruns = underruns; + taken = 0; + dropped = 0; + reported_played = played; + reported = now; + } + + void Close() { + if (stream != nullptr) { + AAudioStream_requestStop(stream); + AAudioStream_close(stream); + stream = nullptr; + } + reported_played = 0; + } + + AAudioStream* stream{}; + int id{}; + uint32_t rate{}; + int32_t burst{1}; + int32_t underruns{}; + int32_t reported_underruns{}; + /// How long a buffer may wait for room; whether the stream has been given up on for now, + /// and how much it had played when that was decided. + std::chrono::nanoseconds patience{200'000'000}; + bool stalled{}; + int64_t read_at_stall{}; + int32_t stalls{}; + /// For the log: frames the stream took and frames it had no room for since the last line. + int64_t taken{}; + int64_t dropped{}; + int64_t reported_played{}; + Clock::time_point reported{}; + Clock::time_point opened{}; +}; + +/// The headset's microphone, for a port the guest listens on. +/// +/// As with the output, nothing here waits inside the audio system: reads only take what has +/// been heard so far. +class AudioInput { +public: + ~AudioInput() { + Close(); + } + + bool Open(uint32_t sample_rate) { + Close(); + // The headset's microphone is a single channel; two are only asked for should that + // ever be refused. + for (const int32_t count : {1, 2}) { + AAudioStreamBuilder* builder = nullptr; + if (AAudio_createStreamBuilder(&builder) != AAUDIO_OK) { + return false; + } + AAudioStreamBuilder_setDirection(builder, AAUDIO_DIRECTION_INPUT); + AAudioStreamBuilder_setFormat(builder, AAUDIO_FORMAT_PCM_I16); + AAudioStreamBuilder_setChannelCount(builder, count); + AAudioStreamBuilder_setSampleRate(builder, static_cast<int32_t>(sample_rate)); + // What the game listens for is somebody blowing, which is noise: the input that + // does without noise suppression and automatic gain. + AAudioStreamBuilder_setInputPreset(builder, AAUDIO_INPUT_PRESET_VOICE_RECOGNITION); + error = AAudioStreamBuilder_openStream(builder, &stream); + AAudioStreamBuilder_delete(builder); + if (error == AAUDIO_OK) { + channels = count; + break; + } + stream = nullptr; + } + if (stream == nullptr) { + return false; + } + error = AAudioStream_requestStart(stream); + if (error != AAUDIO_OK) { + Close(); + return false; + } + return true; + } + + bool IsOpen() const { + return stream != nullptr; + } + + /// Why the last Open failed. + int LastError() const { + return static_cast<int>(error); + } + + /// What the stream is doing, in the audio system's words. + const char* State() const { + return stream != nullptr ? AAudio_convertStreamStateToText(AAudioStream_getState(stream)) + : "closed"; + } + + /// Up to `capacity` frames of 16-bit stereo heard since the last call; negative once the + /// stream is lost. + int32_t Read(int16_t* stereo, int32_t capacity) { + if (channels == 2) { + return AAudioStream_read(stream, stereo, capacity, 0); + } + mono.resize(static_cast<size_t>(capacity)); + const int32_t frames = AAudioStream_read(stream, mono.data(), capacity, 0); + for (int32_t frame = 0; frame < frames; ++frame) { + stereo[frame * 2] = mono[static_cast<size_t>(frame)]; + stereo[frame * 2 + 1] = mono[static_cast<size_t>(frame)]; + } + return frames; + } + + void Close() { + if (stream != nullptr) { + AAudioStream_requestStop(stream); + AAudioStream_close(stream); + stream = nullptr; + } + } + +private: + AAudioStream* stream{}; + int32_t channels{1}; + aaudio_result_t error{AAUDIO_OK}; + std::vector<int16_t> mono; +}; + +double Decibels(double level) { + return level > 0.0 ? 20.0 * std::log10(level) : -120.0; +} + +/// A microphone port of the guest: what the headset hears goes down the socket as 16-bit +/// stereo, as it comes. The guest keeps its own time and takes silence for what does not +/// arrive, so nothing here has to be on time, or to happen at all. +void ServeMicrophone(int fd, uint32_t sample_rate, const MicrophoneSettings& settings) { + using Clock = std::chrono::steady_clock; + AudioInput input; + Clock::time_point tried{}; + bool reported_failure = false; + std::vector<int16_t> samples(static_cast<size_t>(sample_rate / 50) * 2); + + // What the guest was sent, for the log: the game makes "how hard is somebody blowing" of + // the loudness of each 256 frames, so that is the measure. + constexpr size_t BlockSamples = 512; + double block_squares = 0.0; + size_t block_filled = 0; + double loudest = 0.0; + double squares = 0.0; + uint64_t counted = 0; + uint64_t dropped = 0; + uint64_t heard = 0; + auto reported = Clock::now(); + + LOGI("the game listens to the microphone (%u Hz)%s", sample_rate, + !settings.enabled ? ", which is switched off (mic=0)" + : settings.test_signal ? ": a test signal stands in for it" : ""); + const auto started = Clock::now(); + uint64_t generated = 0; + uint32_t noise = 0x2545f491; + while (true) { + // The guest says nothing more on this connection; it ends by closing it. + char discard[64]; + const ssize_t received = ::recv(fd, discard, sizeof(discard), MSG_DONTWAIT); + if (received == 0 || (received < 0 && errno != EAGAIN && errno != EWOULDBLOCK && + errno != EINTR)) { + break; + } + if (!settings.enabled) { + ::usleep(100'000); + continue; + } + + const auto now = Clock::now(); + if (now - reported >= std::chrono::seconds{10}) { + if (counted != 0) { + LOGI("microphone: loudest moment %.1f dB, average %.1f dB (0 dB is full scale; " + "the game takes -9 dB for blowing as hard as it gets, -21 dB for half of " + "that)%s", + Decibels(loudest), Decibels(std::sqrt(squares / counted)), + dropped != 0 ? ", some of it not taken by the emulator" : ""); + } else if (input.IsOpen()) { + // An app nobody looks at is not given the microphone, for one. + LOGI("microphone: nothing came from it in the last ten seconds (stream %s, %llu " + "frames before that)", + input.State(), static_cast<unsigned long long>(heard)); + // A stream opened while the headset slept has been seen to stay like that; + // a new one costs nothing. + input.Close(); + } + heard += counted / 2; + loudest = 0.0; + squares = 0.0; + counted = 0; + dropped = 0; + reported = now; + } + int32_t frames = 0; + if (settings.test_signal) { + // By the clock, a fiftieth of a second at a time. + const auto due = static_cast<uint64_t>( + std::chrono::duration<double>(now - started).count() * sample_rate); + if (due - generated < samples.size() / 2) { + ::usleep(2'000); + continue; + } + frames = static_cast<int32_t>(samples.size() / 2); + // Evenly distributed noise of this amplitude has a root mean square of 0.35. + const bool blowing = generated % (5ull * sample_rate) < sample_rate; + for (size_t i = 0; i < samples.size(); ++i) { + noise ^= noise << 13; + noise ^= noise >> 17; + noise ^= noise << 5; + const float unit = static_cast<float>(noise >> 8) / 8388608.0f - 1.0f; + samples[i] = blowing ? static_cast<int16_t>(unit * 0.606f * 32767.0f) : 0; + } + generated += static_cast<uint64_t>(frames); + } else if (!input.IsOpen()) { + // Without the permission there is no stream. The user may be looking at the + // question right now, so it is tried again. + if (now - tried < std::chrono::seconds{2}) { + ::usleep(100'000); + continue; + } + tried = now; + if (!input.Open(sample_rate)) { + if (!reported_failure) { + LOGW("the microphone cannot be opened (error %d); trying again every two " + "seconds", + input.LastError()); + reported_failure = true; + } + continue; + } + LOGI("microphone opened"); + reported_failure = false; + } + + if (!settings.test_signal) { + frames = input.Read(samples.data(), static_cast<int32_t>(samples.size() / 2)); + } + if (frames < 0) { + LOGW("microphone stream error %d, opening a new one", static_cast<int>(frames)); + input.Close(); + continue; + } + if (frames == 0) { + ::usleep(2'000); + continue; + } + + const size_t count = static_cast<size_t>(frames) * 2; + for (size_t i = 0; i < count; ++i) { + const float amplified = static_cast<float>(samples[i]) * settings.gain; + samples[i] = static_cast<int16_t>(std::clamp(amplified, -32768.0f, 32767.0f)); + const double sample = samples[i] / 32768.0; + block_squares += sample * sample; + if (++block_filled == BlockSamples) { + loudest = std::max(loudest, std::sqrt(block_squares / BlockSamples)); + squares += block_squares; + counted += BlockSamples; + block_squares = 0.0; + block_filled = 0; + } + } + // A guest that is not reading (paused, busy) does not get the sound later instead. + const auto* bytes = reinterpret_cast<const uint8_t*>(samples.data()); + const size_t size = count * sizeof(int16_t); + const ssize_t sent = ::send(fd, bytes, size, MSG_NOSIGNAL | MSG_DONTWAIT); + if (sent < 0 && errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR) { + break; + } + if (sent < static_cast<ssize_t>(size)) { + ++dropped; + // What does get through has to end with a whole frame, or everything after it + // would be read out of step: the few bytes a cut frame lacks are waited for. + constexpr size_t FrameBytes = 2 * sizeof(int16_t); + const size_t cut = sent > 0 ? static_cast<size_t>(sent) % FrameBytes : 0; + if (cut != 0 && ::send(fd, bytes + sent, FrameBytes - cut, MSG_NOSIGNAL) != + static_cast<ssize_t>(FrameBytes - cut)) { + break; + } + } + } + ::close(fd); +} + +/// One audio port of the guest: a framed stream of "prepare" and "PCM" requests. +void ServeAudio(int fd, MicrophoneSettings microphone) { + static constexpr uint8_t RequestPrepare = 4; + static constexpr uint8_t RequestWrite = 5; + static constexpr uint8_t RequestCapture = 6; + + // The emulator's busiest threads run at a raised priority and there are more of them than + // processor cores: whoever carries the sound to the speakers must not queue behind them. + ::setpriority(PRIO_PROCESS, 0, -16); + + AudioOutput output; + std::vector<uint8_t> payload; + while (true) { + uint8_t header[5]; + if (!ReadFully(fd, header, sizeof(header))) { + break; + } + uint32_t size = 0; + std::memcpy(&size, header + 1, sizeof(size)); + if (size > (1u << 24)) { + break; + } + payload.resize(size); + if (size > 0 && !ReadFully(fd, payload.data(), size)) { + break; + } + + if (header[0] == RequestPrepare && size >= 10) { + // channels, sample type, rate, buffer size. The core always sends 16-bit stereo. + uint32_t sample_rate = 0; + std::memcpy(&sample_rate, payload.data() + 2, sizeof(sample_rate)); + output.Open(sample_rate); + } else if (header[0] == RequestWrite) { + output.Play(payload.data(), static_cast<int32_t>(size / 4)); + } else if (header[0] == RequestCapture && size >= 10) { + // The connection is for the other direction from here on. + uint32_t sample_rate = 0; + std::memcpy(&sample_rate, payload.data() + 2, sizeof(sample_rate)); + if (sample_rate >= 8000 && sample_rate <= 96000) { + ServeMicrophone(fd, sample_rate, microphone); + return; + } + break; + } + } + ::close(fd); +} + +} // namespace + +CoreProcess::~CoreProcess() { + Stop(); +} + +std::string CoreProcess::GetMessage() { + std::scoped_lock lock{mutex}; + return message; +} + +void CoreProcess::Fail(const std::string& text) { + LOGE("%s", text.c_str()); + { + std::scoped_lock lock{mutex}; + message = text; + } + state = State::Failed; +} + +bool CoreProcess::Start(const CoreLaunch& launch) { + const std::string run_dir = launch.storage_root + "/run"; + const std::string home = launch.storage_root + "/home"; + const std::string tmp = launch.storage_root + "/tmp"; + const std::string cache = launch.storage_root + "/cache"; + for (const auto& dir : {run_dir, home, tmp, cache, cache + "/mesa"}) { + MakeDirs(dir); + } + + const std::string control_path = run_dir + "/control.sock"; + const std::string audio_path = run_dir + "/audio.sock"; + const std::string vr_path = run_dir + "/vr.sock"; + control_listen = Listen(control_path, SOCK_STREAM); + audio_listen = Listen(audio_path, SOCK_STREAM); + vr_listen = Listen(vr_path, SOCK_SEQPACKET); + if (control_listen < 0 || audio_listen < 0 || vr_listen < 0) { + Fail("Unable to create the sockets the emulator connects to"); + return false; + } + + const std::string host_dir = launch.runtime_root + "/host"; + const std::string driver_dir = launch.runtime_root + "/drivers/turnip"; + const std::string core = host_dir + "/shadps4-arm64-fex"; + // The Vulkan loader opens the driver by name, so its folder has to be searched too. + const std::string library_path = host_dir + ":" + driver_dir; + std::vector<std::string> args = {launch.loader, "--library-path", library_path}; + // Horizon OS only lets apps use the newer half of the GPU driver's memory interface, while + // Turnip still uses the older one for some calls; this library translates between the two. + // It has to go through the loader's own preload option: LD_PRELOAD would also be picked up + // by Android programs the core starts. + const std::string gpu_shim = host_dir + "/libkgsl_compat.so"; + if (::access(gpu_shim.c_str(), R_OK) == 0) { + args.insert(args.end(), {"--preload", gpu_shim}); + } else { + LOGW("%s is missing, the GPU driver will probably fail to allocate memory", + gpu_shim.c_str()); + } + args.insert(args.end(), {core, "--bachata-storage-root", launch.storage_root, + "--bachata-socket", control_path, "-g", launch.game}); + args.insert(args.end(), launch.extra_args.begin(), launch.extra_args.end()); + + std::vector<std::pair<std::string, std::string>> env = { + {"HOME", home}, + {"TMPDIR", tmp}, + {"XDG_CACHE_HOME", cache}, + {"XDG_CONFIG_HOME", home + "/.config"}, + {"XDG_DATA_HOME", home + "/.local/share"}, + {"MESA_SHADER_CACHE_DIR", cache + "/mesa"}, + {"LD_LIBRARY_PATH", library_path}, + // Android's seccomp filter kills processes that register rseq. + {"GLIBC_TUNABLES", "glibc.pthread.rseq=0"}, + {"SDL_VIDEODRIVER", "dummy"}, + {"SDL_AUDIODRIVER", "dummy"}, + {"SDL_VULKAN_LIBRARY", host_dir + "/libvulkan.so.1"}, + {"VK_ICD_FILENAMES", driver_dir + "/freedreno_icd.aarch64.json"}, + {"SHADPS4_HEADLESS", "1"}, + {"SHADPS4_VR_SOCKET", vr_path}, + {"BACHATA_ALSA_SOCKET", audio_path}, + }; + for (const auto& entry : launch.extra_env) { + bool replaced = false; + for (auto& existing : env) { + if (existing.first == entry.first) { + existing.second = entry.second; + replaced = true; + } + } + if (!replaced) { + env.push_back(entry); + } + } + + // Everything the child touches between fork and exec has to exist beforehand. + std::vector<char*> argv; + for (auto& arg : args) { + argv.push_back(arg.data()); + } + argv.push_back(nullptr); + std::vector<std::string> env_strings; + for (const auto& [name, value] : env) { + env_strings.push_back(name + "=" + value); + } + std::vector<char*> envp; + for (auto& entry : env_strings) { + envp.push_back(entry.data()); + } + envp.push_back(nullptr); + + std::string command; + for (const auto& arg : args) { + command += arg + " "; + } + LOGI("starting core: %s", command.c_str()); + + state = State::Starting; + quit = false; + paused = false; + const char* log_path = launch.log_file.c_str(); + const pid_t child = ::fork(); + if (child < 0) { + Fail(std::string{"fork failed: "} + std::strerror(errno)); + return false; + } + if (child == 0) { + const int log = ::open(log_path, O_WRONLY | O_CREAT | O_TRUNC, 0644); + if (log >= 0) { + ::dup2(log, STDOUT_FILENO); + ::dup2(log, STDERR_FILENO); + } + if (::chdir(launch.storage_root.c_str()) != 0) { + ::_exit(126); + } + ::execve(argv[0], argv.data(), envp.data()); + ::_exit(127); + } + pid = child; + + control_thread = std::thread{[this] { ControlLoop(); }}; + audio_thread = std::thread{[this] { AudioLoop(); }}; + vr_thread = std::thread{[this] { VrLoop(); }}; + wait_thread = std::thread{[this] { WaitLoop(); }}; + return true; +} + +void CoreProcess::Stop() { + if (state == State::Idle && pid < 0) { + return; + } + quit = true; + if (pid > 0) { + // A stopped process does not see a request to terminate. + ::kill(pid, SIGCONT); + ::kill(pid, SIGTERM); + } + for (std::thread* thread : {&wait_thread, &control_thread, &audio_thread, &vr_thread}) { + if (thread->joinable()) { + thread->join(); + } + } + for (int* fd : {&control_listen, &audio_listen, &vr_listen}) { + if (*fd >= 0) { + ::close(*fd); + *fd = -1; + } + } + pid = -1; + state = State::Idle; +} + +void CoreProcess::WaitLoop() { + int status = 0; + auto asked_to_quit = std::chrono::steady_clock::time_point{}; + // Every half minute, what the emulator uses: its share of the processors tells whether it + // runs or hangs, and the processors it is allowed on differ with how the app was started. + auto reported = std::chrono::steady_clock::now(); + double reported_cpu = 0.0; + uint64_t reported_frames = 0; + while (true) { + if (const auto now = std::chrono::steady_clock::now(); + now - reported >= std::chrono::seconds{30} && !paused && !quit) { + const Usage usage = GetUsage(); + const double seconds = std::chrono::duration<double>(now - reported).count(); + const uint64_t frames = presented_frames; + LOGI("emulator: %.0f%% of a processor on %s, %d MB, %.1f frames a second", + (usage.cpu_seconds - reported_cpu) * 100.0 / seconds, + usage.cpus.empty() ? "?" : usage.cpus.c_str(), usage.memory_mb, + static_cast<double>(frames - reported_frames) / seconds); + reported = now; + reported_cpu = usage.cpu_seconds; + reported_frames = frames; + } + const pid_t child = pid; + const pid_t result = ::waitpid(child, &status, WNOHANG); + if (result == child || (result < 0 && errno != EINTR)) { + break; + } + if (quit) { + // A core that ignores SIGTERM for two seconds is killed. + const auto now = std::chrono::steady_clock::now(); + if (asked_to_quit == std::chrono::steady_clock::time_point{}) { + asked_to_quit = now; + } else if (now - asked_to_quit > std::chrono::seconds{2}) { + ::kill(pid, SIGKILL); + } + } + ::usleep(50'000); + } + + char text[128]; + if (WIFEXITED(status)) { + std::snprintf(text, sizeof(text), "The emulator exited with code %d", WEXITSTATUS(status)); + } else if (WIFSIGNALED(status)) { + std::snprintf(text, sizeof(text), "The emulator was stopped by signal %d", + WTERMSIG(status)); + } else { + std::snprintf(text, sizeof(text), "The emulator stopped"); + } + LOGI("%s", text); + { + std::scoped_lock lock{mutex}; + if (message.empty()) { + message = text; + } else { + message = std::string{text} + " (" + message + ")"; + } + } + const bool clean = WIFEXITED(status) && WEXITSTATUS(status) == 0; + state = clean || quit ? State::Stopped : State::Failed; +} + +void CoreProcess::SetPaused(bool pause) { + const pid_t child = pid; + if (child <= 0 || paused.exchange(pause) == pause) { + return; + } + LOGI("%s the emulator", pause ? "pausing" : "resuming"); + ::kill(child, pause ? SIGSTOP : SIGCONT); +} + +pid_t CoreProcess::FindThread(const std::string& prefix) const { + const auto threads = FindThreads(prefix); + return threads.empty() ? 0 : threads.front(); +} + +std::vector<pid_t> CoreProcess::FindThreads(const std::string& prefix) const { + std::vector<pid_t> found; + const pid_t child = pid; + if (child <= 0) { + return found; + } + const std::string tasks = "/proc/" + std::to_string(child) + "/task"; + DIR* dir = ::opendir(tasks.c_str()); + if (dir == nullptr) { + return found; + } + while (const dirent* entry = ::readdir(dir)) { + const pid_t tid = static_cast<pid_t>(std::atoi(entry->d_name)); + if (tid <= 0) { + continue; + } + char name[32]{}; + const std::string path = tasks + "/" + entry->d_name + "/comm"; + const int fd = ::open(path.c_str(), O_RDONLY | O_CLOEXEC); + if (fd < 0) { + continue; + } + const ssize_t length = ::read(fd, name, sizeof(name) - 1); + ::close(fd); + // The kernel keeps the first 15 characters of a thread's name. + if (length > 0 && prefix.compare(0, 15, name, std::min<size_t>(prefix.size(), 15)) == 0) { + found.push_back(tid); + } + } + ::closedir(dir); + return found; +} + +CoreProcess::Usage CoreProcess::GetUsage() const { + Usage usage; + const pid_t child = pid; + if (child <= 0) { + return usage; + } + const auto read_file = [](const std::string& path) { + std::string text; + const int fd = ::open(path.c_str(), O_RDONLY | O_CLOEXEC); + if (fd < 0) { + return text; + } + char chunk[4096]; + ssize_t count; + while ((count = ::read(fd, chunk, sizeof(chunk))) > 0) { + text.append(chunk, static_cast<size_t>(count)); + } + ::close(fd); + return text; + }; + const std::string base = "/proc/" + std::to_string(child); + + // The name in the second field may hold anything, spaces included: count from its end. + const std::string stat = read_file(base + "/stat"); + const size_t name_end = stat.rfind(')'); + if (name_end != std::string::npos) { + unsigned long long user = 0; + unsigned long long system = 0; + // state ppid pgrp session tty tpgid flags minflt cminflt majflt cmajflt utime stime + if (std::sscanf(stat.c_str() + name_end + 1, + " %*c %*d %*d %*d %*d %*d %*u %*u %*u %*u %*u %llu %llu", &user, + &system) == 2) { + usage.cpu_seconds = + static_cast<double>(user + system) / static_cast<double>(::sysconf(_SC_CLK_TCK)); + } + } + + const std::string status = read_file(base + "/status"); + const auto field = [&](const char* name) { + const size_t at = status.find(name); + if (at == std::string::npos) { + return std::string{}; + } + size_t begin = at + std::strlen(name); + while (begin < status.size() && (status[begin] == ' ' || status[begin] == '\t')) { + ++begin; + } + const size_t end = status.find('\n', begin); + return status.substr(begin, end == std::string::npos ? end : end - begin); + }; + usage.cpus = field("Cpus_allowed_list:"); + usage.memory_mb = std::atoi(field("VmRSS:").c_str()) / 1024; + return usage; +} + +void CoreProcess::SetMicrophone(bool enabled, float gain, bool test_signal) { + microphone.enabled = enabled; + microphone.gain = gain; + microphone.test_signal = test_signal; +} + +void CoreProcess::SetPad(const PadState& new_pad) { + std::scoped_lock lock{mutex}; + pad = new_pad; +} + +void CoreProcess::ControlLoop() { + const int fd = Accept(control_listen, quit); + if (fd < 0) { + return; + } + control_fd = fd; + LOGI("core connected to the control socket"); + + std::string line; + PadState last_sent; + bool sent_once = false; + uint64_t sequence = 0; + auto last_send = std::chrono::steady_clock::now(); + + while (!quit) { + pollfd poll_fd{.fd = fd, .events = POLLIN, .revents = 0}; + const int ready = ::poll(&poll_fd, 1, 4); + if (ready > 0) { + char chunk[512]; + const ssize_t count = ::recv(fd, chunk, sizeof(chunk), 0); + if (count == 0 || (count < 0 && errno != EINTR)) { + break; + } + for (ssize_t i = 0; i < count; ++i) { + if (chunk[i] != '\n') { + if (line.size() < 1024) { + line.push_back(chunk[i]); + } + continue; + } + if (line == "BACHATA/1 EVENT Frame") { + ++presented_frames; + } else if (line == "BACHATA/1 EVENT Running") { + state = State::Running; + LOGI("core: running"); + } else if (line.rfind("BACHATA/1 ERROR code=", 0) == 0) { + std::scoped_lock lock{mutex}; + message = "emulator error " + line.substr(21); + LOGE("core: %s", line.c_str()); + } else { + LOGI("core: %s", line.c_str()); + } + line.clear(); + } + } + + PadState current; + { + std::scoped_lock lock{mutex}; + current = pad; + } + const auto now = std::chrono::steady_clock::now(); + const bool changed = !sent_once || !(current == last_sent); + // Motion samples are a stream; everything else only needs sending when it changes, plus + // a slow heartbeat. + const auto interval = current.has_motion ? std::chrono::milliseconds{4} + : std::chrono::milliseconds{100}; + if (!changed && now - last_send < interval) { + continue; + } + + char text[512]; + int length = std::snprintf( + text, sizeof(text), + "BACHATA/1 INPUT slot=0 seq=%" PRIu64 + " buttons=0x%x lx=%u ly=%u rx=%u ry=%u l2=%u r2=%u touch=%d tx=%u ty=%u", + ++sequence, current.buttons, current.left_x, current.left_y, current.right_x, + current.right_y, current.left_trigger, current.right_trigger, + current.touch_down ? 1 : 0, current.touch_x, current.touch_y); + if (current.has_motion) { + const auto milli = [](float value) { + const float scaled = value * 1000.0f; + return static_cast<int>(scaled < -999999.0f ? -999999.0f + : scaled > 999999.0f ? 999999.0f + : scaled); + }; + length += std::snprintf(text + length, sizeof(text) - length, + " gx=%d gy=%d gz=%d ax=%d ay=%d az=%d", + milli(current.gyro[0]), milli(current.gyro[1]), + milli(current.gyro[2]), milli(current.accel[0]), + milli(current.accel[1]), milli(current.accel[2])); + } + text[length++] = '\n'; + if (::send(fd, text, static_cast<size_t>(length), MSG_NOSIGNAL) < 0) { + break; + } + last_sent = current; + sent_once = true; + last_send = now; + } + + control_fd = -1; + ::close(fd); +} + +void CoreProcess::AudioLoop() { + while (!quit) { + const int fd = Accept(audio_listen, quit); + if (fd < 0) { + break; + } + // The guest opens and closes ports as it likes; each lives until its socket closes, + // which happens at the latest when the core exits. + std::thread{ServeAudio, fd, microphone}.detach(); + } +} + +void CoreProcess::SetBuffers(const std::vector<int>& fds, uint32_t width, uint32_t height, + uint32_t stride) { + std::scoped_lock lock{mutex}; + buffer_fds = fds; + buffers = {}; + buffers.count = static_cast<uint32_t>(fds.size()); + buffers.width = width; + buffers.height = height; + buffers.stride = stride; + buffers_sent = false; + SendBuffersLocked(); +} + +void CoreProcess::SendBuffersLocked() { + const int fd = vr_fd; + if (fd < 0 || buffers_sent || buffer_fds.empty()) { + return; + } + alignas(cmsghdr) char control[CMSG_SPACE(sizeof(int) * Protocol::MaxBuffers)]{}; + iovec io{.iov_base = &buffers, .iov_len = sizeof(buffers)}; + msghdr header{}; + header.msg_iov = &io; + header.msg_iovlen = 1; + header.msg_control = control; + header.msg_controllen = CMSG_SPACE(sizeof(int) * buffer_fds.size()); + cmsghdr* cmsg = CMSG_FIRSTHDR(&header); + cmsg->cmsg_level = SOL_SOCKET; + cmsg->cmsg_type = SCM_RIGHTS; + cmsg->cmsg_len = CMSG_LEN(sizeof(int) * buffer_fds.size()); + std::memcpy(CMSG_DATA(cmsg), buffer_fds.data(), sizeof(int) * buffer_fds.size()); + if (::sendmsg(fd, &header, MSG_NOSIGNAL) < 0) { + LOGE("unable to offer the frame buffers: %s", std::strerror(errno)); + return; + } + buffers_sent = true; + LOGI("offered %u frame buffers of %ux%u to the core", buffers.count, buffers.width, + buffers.height); +} + +void CoreProcess::SendPose(const Protocol::Pose& pose) { + const int fd = vr_fd; + if (fd >= 0) { + ::send(fd, &pose, sizeof(pose), MSG_NOSIGNAL | MSG_DONTWAIT); + } +} + +void CoreProcess::SendPadPose(const Protocol::PadPose& pose) { + const int fd = vr_fd; + if (fd >= 0) { + ::send(fd, &pose, sizeof(pose), MSG_NOSIGNAL | MSG_DONTWAIT); + } +} + +void CoreProcess::SendOptics(float ipd) { + const int fd = vr_fd; + if (fd >= 0) { + Protocol::Optics optics; + optics.ipd = ipd; + ::send(fd, &optics, sizeof(optics), MSG_NOSIGNAL | MSG_DONTWAIT); + } +} + +void CoreProcess::SendRefresh(float rate) { + const int fd = vr_fd; + if (fd >= 0) { + Protocol::Refresh refresh; + refresh.rate = rate; + // std::chrono::steady_clock is the clock the emulator reads too. + refresh.time = static_cast<uint64_t>( + std::chrono::duration_cast<std::chrono::nanoseconds>( + std::chrono::steady_clock::now().time_since_epoch()) + .count()); + ::send(fd, &refresh, sizeof(refresh), MSG_NOSIGNAL | MSG_DONTWAIT); + } +} + +std::optional<Protocol::Frame> CoreProcess::TakeFrame() { + std::scoped_lock lock{mutex}; + std::optional<Protocol::Frame> result; + result.swap(frame); + return result; +} + +void CoreProcess::VrLoop() { + ::setpriority(PRIO_PROCESS, 0, -12); + const int fd = Accept(vr_listen, quit); + if (fd < 0) { + return; + } + LOGI("core connected to the VR socket"); + { + std::scoped_lock lock{mutex}; + vr_fd = fd; + SendBuffersLocked(); + } + + while (!quit) { + pollfd poll_fd{.fd = fd, .events = POLLIN, .revents = 0}; + const int ready = ::poll(&poll_fd, 1, 200); + if (ready < 0 && errno != EINTR) { + break; + } + if (ready <= 0) { + continue; + } + union { + Protocol::Header header; + Protocol::Frame frame; + Protocol::PadFeedback feedback; + } received{}; + const ssize_t size = ::recv(fd, &received, sizeof(received), 0); + if (size == 0 || (size < 0 && errno != EINTR)) { + break; + } + if (size < static_cast<ssize_t>(sizeof(Protocol::Header)) || + received.header.magic != Protocol::Magic) { + continue; + } + if (received.header.type == Protocol::MessageType::Frame && + size == static_cast<ssize_t>(sizeof(Protocol::Frame))) { + std::scoped_lock lock{mutex}; + frame = received.frame; + } else if (received.header.type == Protocol::MessageType::PadFeedback && + size == static_cast<ssize_t>(sizeof(Protocol::PadFeedback))) { + const auto& feedback = received.feedback; + pad_feedback = uint64_t{feedback.small_motor} | uint64_t{feedback.large_motor} << 8 | + uint64_t{feedback.red} << 16 | uint64_t{feedback.green} << 24 | + uint64_t{feedback.blue} << 32; + } + } + + vr_fd = -1; + ::close(fd); +} diff --git a/quest-host/cpp/core_process.h b/quest-host/cpp/core_process.h new file mode 100644 index 0000000..4a3135d --- /dev/null +++ b/quest-host/cpp/core_process.h @@ -0,0 +1,147 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +#pragma once + +#include <array> +#include <atomic> +#include <cstdint> +#include <mutex> +#include <optional> +#include <string> +#include <thread> +#include <vector> + +#include <sys/types.h> + +#include "vr_protocol.h" + +/// What the emulated DualShock 4 looks like right now. Buttons use the PS4 pad bit layout. +struct PadState { + uint32_t buttons{}; + uint8_t left_x{128}, left_y{128}, right_x{128}, right_y{128}; + uint8_t left_trigger{}, right_trigger{}; + bool touch_down{}; + uint16_t touch_x{}, touch_y{}; + bool has_motion{}; + float gyro[3]{}; + float accel[3]{0.0f, 9.81f, 0.0f}; + + bool operator==(const PadState&) const = default; +}; + +/// Whether the game may listen to the headset's microphone, and how much louder than it is +/// what it hears should be made. +struct MicrophoneSettings { + bool enabled{true}; + float gain{1.0f}; + /// For tests nobody is there to blow for: instead of the microphone, a second of noise + /// every five, as loud as the game takes blowing hard to be. + bool test_signal{}; +}; + +/// Everything needed to start the emulator core. +struct CoreLaunch { + std::string loader; ///< glibc's dynamic loader, inside the app's native library folder + std::string runtime_root; ///< extracted runtime: host/ (libraries, core), drivers/ + std::string storage_root; ///< writable folder the core keeps its data in + std::string game; ///< path of the game's eboot.bin + std::string log_file; + std::vector<std::string> extra_args; + std::vector<std::pair<std::string, std::string>> extra_env; +}; + +/// Runs the emulator core as a child process and serves the sockets it talks to: the control +/// line protocol (state out, controller in), audio, and the VR frame/pose channel. +class CoreProcess { +public: + enum class State { Idle, Starting, Running, Stopped, Failed }; + + CoreProcess() = default; + ~CoreProcess(); + + bool Start(const CoreLaunch& launch); + void Stop(); + + State GetState() const { + return state.load(); + } + /// Human-readable reason once the state is Stopped or Failed. + std::string GetMessage(); + /// Frames the core reported as presented so far. + uint64_t GetPresentedFrames() const { + return presented_frames.load(); + } + + void SetPad(const PadState& pad); + + /// Freezes the emulator while nobody is looking (headset taken off), or lets it go on. + void SetPaused(bool paused); + + /// Offers the frame buffers to the core. `fds` are dma-bufs, they stay owned by the caller. + void SetBuffers(const std::vector<int>& fds, uint32_t width, uint32_t height, uint32_t stride); + void SendPose(const Core::Vr::Protocol::Pose& pose); + void SendPadPose(const Core::Vr::Protocol::PadPose& pose); + void SendOptics(float ipd); + /// The display refreshes: the emulated headset keeps step with it (`rate` in Hz). + void SendRefresh(float rate); + /// Returns the newest frame the core finished since the last call, if any. + std::optional<Core::Vr::Protocol::Frame> TakeFrame(); + + /// What the game last asked of the controller, packed: small motor, large motor, red, + /// green, blue, one byte each from the lowest up. + uint64_t GetPadFeedback() const { + return pad_feedback.load(); + } + + /// What the emulator process has used: processor time since it started, the processors it + /// may run on (as the system lists them, "0-5") and its memory. + struct Usage { + double cpu_seconds{}; + std::string cpus; + int memory_mb{}; + }; + Usage GetUsage() const; + + /// Applies to microphone ports the game opens from now on. + void SetMicrophone(bool enabled, float gain, bool test_signal = false); + + /// Thread id of the core's thread whose name starts with `prefix`, or 0. + pid_t FindThread(const std::string& prefix) const; + /// All threads of the emulator whose names begin with `prefix`. + std::vector<pid_t> FindThreads(const std::string& prefix) const; + +private: + void ControlLoop(); + void AudioLoop(); + void VrLoop(); + void WaitLoop(); + void SendBuffersLocked(); + void Fail(const std::string& message); + + std::atomic<State> state{State::Idle}; + std::atomic<bool> quit{}; + std::atomic<bool> paused{}; + std::atomic<uint64_t> presented_frames{}; + std::atomic<uint64_t> pad_feedback{}; + std::atomic<pid_t> pid{-1}; + + int control_listen{-1}; + int audio_listen{-1}; + int vr_listen{-1}; + std::atomic<int> control_fd{-1}; + std::atomic<int> vr_fd{-1}; + + std::thread control_thread; + std::thread audio_thread; + std::thread vr_thread; + std::thread wait_thread; + + MicrophoneSettings microphone; + + std::mutex mutex; + std::string message; + PadState pad; + std::optional<Core::Vr::Protocol::Frame> frame; + std::vector<int> buffer_fds; + Core::Vr::Protocol::Buffers buffers{}; + bool buffers_sent{}; +}; diff --git a/quest-host/cpp/gl_frames.cpp b/quest-host/cpp/gl_frames.cpp new file mode 100644 index 0000000..07584c9 --- /dev/null +++ b/quest-host/cpp/gl_frames.cpp @@ -0,0 +1,256 @@ +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "gl_frames.h" + +#include <cstring> + +#include <android/hardware_buffer.h> +#include <dlfcn.h> + +#include "core_process.h" +#include "log.h" + +namespace { + +/// How gralloc describes a buffer; the first file descriptor is the dma-buf with the pixels. +struct NativeHandle { + int version; + int num_fds; + int num_ints; + int data[1]; +}; + +GLuint CompileShader(GLenum type, const char* source) { + const GLuint shader = glCreateShader(type); + glShaderSource(shader, 1, &source, nullptr); + glCompileShader(shader); + GLint ok = GL_FALSE; + glGetShaderiv(shader, GL_COMPILE_STATUS, &ok); + if (ok != GL_TRUE) { + char log[512]; + glGetShaderInfoLog(shader, sizeof(log), nullptr, log); + LOGE("shader compilation failed: %s", log); + } + return shader; +} + +const char* const BlitVertexShader = R"(#version 300 es +out vec2 uv; +void main() { + vec2 corner = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2)); + // The frame's first row is its top row, GL's first row is the bottom one. + uv = vec2(corner.x, 1.0 - corner.y); + gl_Position = vec4(corner * 2.0 - 1.0, 0.0, 1.0); +} +)"; + +const char* const BlitFragmentShader = R"(#version 300 es +precision highp float; +uniform sampler2D frame; +uniform int swap_red_blue; +uniform int decode_srgb; +in vec2 uv; +out vec4 color; +void main() { + vec3 c = texture(frame, uv).rgb; + if (swap_red_blue != 0) { + c = c.bgr; + } + // The emulator delivers display-ready values. An sRGB target encodes whatever is written to + // it, so those have to be made linear first. + if (decode_srgb != 0) { + c = mix(c / 12.92, pow((c + 0.055) / 1.055, vec3(2.4)), step(0.04045, c)); + } + color = vec4(c, 1.0); +} +)"; + +} // namespace + +bool GlContext::Create() { + display = eglGetDisplay(EGL_DEFAULT_DISPLAY); + if (display == EGL_NO_DISPLAY || !eglInitialize(display, nullptr, nullptr)) { + LOGE("eglInitialize failed"); + return false; + } + const EGLint config_attributes[] = { + EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT, EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, + EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, + EGL_BLUE_SIZE, 8, EGL_ALPHA_SIZE, 8, + EGL_DEPTH_SIZE, 0, EGL_NONE, + }; + EGLint num_configs = 0; + if (!eglChooseConfig(display, config_attributes, &config, 1, &num_configs) || + num_configs < 1) { + LOGE("eglChooseConfig failed"); + return false; + } + const EGLint context_attributes[] = {EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE}; + context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attributes); + // Nothing is drawn to this surface, the context just needs one to be current. + const EGLint surface_attributes[] = {EGL_WIDTH, 16, EGL_HEIGHT, 16, EGL_NONE}; + surface = eglCreatePbufferSurface(display, config, surface_attributes); + if (context == EGL_NO_CONTEXT || surface == EGL_NO_SURFACE || + !eglMakeCurrent(display, surface, surface, context)) { + LOGE("unable to create the GL context: 0x%x", eglGetError()); + return false; + } + return true; +} + +void GlContext::Destroy() { + if (display == EGL_NO_DISPLAY) { + return; + } + eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); + if (surface != EGL_NO_SURFACE) { + eglDestroySurface(display, surface); + } + if (context != EGL_NO_CONTEXT) { + eglDestroyContext(display, context); + } + eglTerminate(display); + display = EGL_NO_DISPLAY; + surface = EGL_NO_SURFACE; + context = EGL_NO_CONTEXT; +} + +bool FrameBuffers::Create(EGLDisplay display, uint32_t width, uint32_t height, + CoreProcess& core) { + using GetNativeHandle = const NativeHandle* (*)(const AHardwareBuffer*); + const auto get_native_handle = reinterpret_cast<GetNativeHandle>( + dlsym(RTLD_DEFAULT, "AHardwareBuffer_getNativeHandle")); + if (get_native_handle == nullptr) { + LOGE("AHardwareBuffer_getNativeHandle is not available"); + return false; + } + + AHardwareBuffer_Desc description{}; + description.width = width; + description.height = height; + description.layers = 1; + description.format = AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM; + // The CPU bits keep the buffer in a plain row-by-row layout, which is what the emulator's + // GPU driver can attach to and what its fallback path writes. + description.usage = + AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER | + AHARDWAREBUFFER_USAGE_CPU_READ_RARELY | AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY; + + std::vector<int> fds; + uint32_t stride = 0; + for (uint32_t i = 0; i < Count; ++i) { + AHardwareBuffer* buffer = nullptr; + if (AHardwareBuffer_allocate(&description, &buffer) != 0) { + LOGE("unable to allocate frame buffer %u", i); + return false; + } + buffers.push_back(buffer); + AHardwareBuffer_Desc actual{}; + AHardwareBuffer_describe(buffer, &actual); + stride = actual.stride; + + const NativeHandle* handle = get_native_handle(buffer); + if (handle == nullptr || handle->num_fds < 1) { + LOGE("frame buffer %u has no file descriptor", i); + return false; + } + fds.push_back(handle->data[0]); + + const EGLClientBuffer client_buffer = eglGetNativeClientBufferANDROID(buffer); + const EGLint image_attributes[] = {EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE}; + const EGLImageKHR image = eglCreateImageKHR(display, EGL_NO_CONTEXT, + EGL_NATIVE_BUFFER_ANDROID, client_buffer, + image_attributes); + if (image == EGL_NO_IMAGE_KHR) { + LOGE("unable to wrap frame buffer %u in an EGL image: 0x%x", i, eglGetError()); + return false; + } + images.push_back(image); + + GLuint texture = 0; + glGenTextures(1, &texture); + glBindTexture(GL_TEXTURE_2D, texture); + glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + textures.push_back(texture); + } + LOGI("frame buffers: %u x %ux%u, stride %u", Count, width, height, stride); + core.SetBuffers(fds, width, height, stride); + return true; +} + +void FrameBuffers::Destroy(EGLDisplay display) { + for (const GLuint texture : textures) { + glDeleteTextures(1, &texture); + } + for (const EGLImageKHR image : images) { + eglDestroyImageKHR(display, image); + } + for (AHardwareBuffer* buffer : buffers) { + AHardwareBuffer_release(buffer); + } + textures.clear(); + images.clear(); + buffers.clear(); +} + +bool FrameBlitter::Create() { + const GLuint vertex = CompileShader(GL_VERTEX_SHADER, BlitVertexShader); + const GLuint fragment = CompileShader(GL_FRAGMENT_SHADER, BlitFragmentShader); + program = glCreateProgram(); + glAttachShader(program, vertex); + glAttachShader(program, fragment); + glLinkProgram(program); + glDeleteShader(vertex); + glDeleteShader(fragment); + GLint linked = GL_FALSE; + glGetProgramiv(program, GL_LINK_STATUS, &linked); + if (linked != GL_TRUE) { + LOGE("unable to link the blit program"); + return false; + } + uniform_swap = glGetUniformLocation(program, "swap_red_blue"); + uniform_decode = glGetUniformLocation(program, "decode_srgb"); + glGenVertexArrays(1, &vertex_array); + const char* extensions = reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS)); + write_control = + extensions != nullptr && std::strstr(extensions, "GL_EXT_sRGB_write_control") != nullptr; + return true; +} + +void FrameBlitter::Destroy() { + if (program != 0) { + glDeleteProgram(program); + program = 0; + } + if (vertex_array != 0) { + glDeleteVertexArrays(1, &vertex_array); + vertex_array = 0; + } +} + +void FrameBlitter::Draw(GLuint texture, uint32_t width, uint32_t height, bool swap_red_blue, + bool srgb_target) const { + glViewport(0, 0, static_cast<GLsizei>(width), static_cast<GLsizei>(height)); + glDisable(GL_BLEND); + glDisable(GL_DEPTH_TEST); + glDisable(GL_SCISSOR_TEST); + const bool unencoded = srgb_target && write_control; + if (unencoded) { + glDisable(GL_FRAMEBUFFER_SRGB_EXT); + } + glUseProgram(program); + glUniform1i(uniform_swap, swap_red_blue ? 1 : 0); + glUniform1i(uniform_decode, srgb_target && !write_control ? 1 : 0); + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, texture); + glBindVertexArray(vertex_array); + glDrawArrays(GL_TRIANGLES, 0, 3); + if (unencoded) { + // As it is by default: everything else drawn to such a target counts on it. + glEnable(GL_FRAMEBUFFER_SRGB_EXT); + } +} diff --git a/quest-host/cpp/gl_frames.h b/quest-host/cpp/gl_frames.h new file mode 100644 index 0000000..63a0a88 --- /dev/null +++ b/quest-host/cpp/gl_frames.h @@ -0,0 +1,80 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +#pragma once + +// The GL side of showing the emulator's frames, shared by the OpenXR host and by the self test +// that exercises the same path without a headset session. + +#include <cstdint> +#include <vector> + +// Extension entry points (EGL images over hardware buffers) are only declared on request. +#define EGL_EGLEXT_PROTOTYPES +#define GL_GLEXT_PROTOTYPES +#include <EGL/egl.h> +#include <EGL/eglext.h> +#include <GLES3/gl3.h> +// The extension header relies on the types the one above defines. +#include <GLES2/gl2ext.h> + +struct AHardwareBuffer; +class CoreProcess; + +/// An OpenGL ES 3 context that draws to nothing: everything is rendered to textures. +struct GlContext { + EGLDisplay display{EGL_NO_DISPLAY}; + EGLConfig config{}; + EGLContext context{EGL_NO_CONTEXT}; + EGLSurface surface{EGL_NO_SURFACE}; + + bool Create(); + void Destroy(); +}; + +/// The images the emulator renders into: hardware buffers handed to it as dma-bufs, each of them +/// also a GL texture here, so that a frame gets from one process to the other without a copy. +class FrameBuffers { +public: + static constexpr uint32_t Count = 3; + + /// Allocates the buffers and offers them to the core. Needs a current GL context. + bool Create(EGLDisplay display, uint32_t width, uint32_t height, CoreProcess& core); + void Destroy(EGLDisplay display); + + bool IsValid(uint32_t index) const { + return index < textures.size(); + } + GLuint Texture(uint32_t index) const { + return textures[index]; + } + +private: + std::vector<AHardwareBuffer*> buffers; + std::vector<EGLImageKHR> images; + std::vector<GLuint> textures; +}; + +/// Copies a frame to the framebuffer that is bound, upside up and in the right color encoding. +class FrameBlitter { +public: + bool Create(); + void Destroy(); + + /// `srgb_target` is for sRGB targets: they encode whatever is written to them, while the + /// emulator delivers values that are display-ready already. Where the GPU can be told to + /// leave that encoding out, the frame is written as it is; elsewhere it is decoded first, + /// which costs a power function per pixel. + void Draw(GLuint texture, uint32_t width, uint32_t height, bool swap_red_blue, + bool srgb_target) const; + + /// Whether frames go into sRGB targets unchanged (see Draw). + bool WritesUnencoded() const { + return write_control; + } + +private: + GLuint program{}; + GLuint vertex_array{}; + GLint uniform_swap{-1}; + GLint uniform_decode{-1}; + bool write_control{}; +}; diff --git a/quest-host/cpp/log.cpp b/quest-host/cpp/log.cpp new file mode 100644 index 0000000..c06214f --- /dev/null +++ b/quest-host/cpp/log.cpp @@ -0,0 +1,55 @@ +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "log.h" + +#include <cstdarg> +#include <cstdio> +#include <ctime> +#include <mutex> +#include <string> + +namespace { + +std::mutex g_mutex; +FILE* g_file = nullptr; + +} // namespace + +void SetLogFile(const char* path) { + std::scoped_lock lock{g_mutex}; + if (g_file != nullptr) { + std::fclose(g_file); + } + // "e": the emulator process must not inherit the file. + g_file = std::fopen(path, "we"); +} + +void HostLog(int priority, const char* format, ...) { + va_list args; + va_start(args, format); + va_list measure; + va_copy(measure, args); + const int length = std::vsnprintf(nullptr, 0, format, measure); + va_end(measure); + std::string text(length > 0 ? static_cast<size_t>(length) : 0, '\0'); + if (length > 0) { + std::vsnprintf(text.data(), text.size() + 1, format, args); + } + va_end(args); + + __android_log_write(priority, LOG_TAG, text.c_str()); + + std::scoped_lock lock{g_mutex}; + if (g_file == nullptr) { + return; + } + timespec now{}; + clock_gettime(CLOCK_REALTIME, &now); + tm local{}; + localtime_r(&now.tv_sec, &local); + const char level = priority >= ANDROID_LOG_ERROR ? 'E' : priority >= ANDROID_LOG_WARN ? 'W' : 'I'; + std::fprintf(g_file, "%02d:%02d:%02d.%03ld %c %s\n", local.tm_hour, local.tm_min, local.tm_sec, + now.tv_nsec / 1'000'000, level, text.c_str()); + // A session can end by the app being killed. + std::fflush(g_file); +} diff --git a/quest-host/cpp/log.h b/quest-host/cpp/log.h new file mode 100644 index 0000000..097dc24 --- /dev/null +++ b/quest-host/cpp/log.h @@ -0,0 +1,16 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +#pragma once + +#include <android/log.h> + +#define LOG_TAG "AstroVR" + +/// Writes a line to the system log and, once SetLogFile was called, to that file too. The system +/// log is a ring shared with everything else on the headset: by the time somebody asks what +/// happened in a session, it has moved on. +void HostLog(int priority, const char* format, ...) __attribute__((format(printf, 2, 3))); +void SetLogFile(const char* path); + +#define LOGI(...) HostLog(ANDROID_LOG_INFO, __VA_ARGS__) +#define LOGW(...) HostLog(ANDROID_LOG_WARN, __VA_ARGS__) +#define LOGE(...) HostLog(ANDROID_LOG_ERROR, __VA_ARGS__) diff --git a/quest-host/cpp/main.cpp b/quest-host/cpp/main.cpp new file mode 100644 index 0000000..39ab379 --- /dev/null +++ b/quest-host/cpp/main.cpp @@ -0,0 +1,268 @@ +// SPDX-License-Identifier: GPL-2.0-or-later + +// JNI surface of com.astrobotquest.vrhost.MainActivity. The activity owns the lifecycle and +// everything that is easier in Java (controller events, drawing text, unpacking the runtime); +// this side owns the OpenXR session and the emulator process. + +#include <algorithm> +#include <atomic> +#include <cstring> +#include <memory> +#include <mutex> +#include <string> +#include <thread> +#include <vector> + +#include <jni.h> +#include <sys/resource.h> + +#include "core_process.h" +#include "log.h" +#include "xr_host.h" + +namespace { + +struct App { + JavaVM* vm{}; + jobject activity{}; + CoreProcess core; + StatusImage status; + XrHostStatus xr_status; + std::thread xr_thread; + std::atomic<bool> quit{}; + std::atomic<uint32_t> recenter_requests{}; + std::mutex pad_mutex; + PadState pad; +}; + +std::unique_ptr<App> g_app; + +std::string ToString(JNIEnv* env, jstring text) { + if (text == nullptr) { + return {}; + } + const char* chars = env->GetStringUTFChars(text, nullptr); + std::string result{chars != nullptr ? chars : ""}; + env->ReleaseStringUTFChars(text, chars); + return result; +} + +std::vector<std::string> ToStrings(JNIEnv* env, jobjectArray array) { + std::vector<std::string> result; + const jsize count = array != nullptr ? env->GetArrayLength(array) : 0; + for (jsize i = 0; i < count; ++i) { + const auto element = static_cast<jstring>(env->GetObjectArrayElement(array, i)); + result.push_back(ToString(env, element)); + env->DeleteLocalRef(element); + } + return result; +} + +} // namespace + +extern "C" { + +JNIEXPORT void JNICALL Java_com_astrobotquest_vrhost_MainActivity_nativeStartXr( + JNIEnv* env, jobject activity, jfloat refresh_rate, jint eye_width, jint eye_height, + jboolean track_hands, jint sharpen, jboolean cubic, jboolean show_stats, jfloat predict_ms, + jint dynamic_resolution, jboolean cpu_boost) { + if (g_app) { + return; + } + g_app = std::make_unique<App>(); + env->GetJavaVM(&g_app->vm); + g_app->activity = env->NewGlobalRef(activity); + + XrHostOptions options; + options.refresh_rate = refresh_rate; + options.eye_width = static_cast<uint32_t>(eye_width); + options.eye_height = static_cast<uint32_t>(eye_height); + options.track_hands = track_hands == JNI_TRUE; + options.sharpen = sharpen; + options.cubic = cubic == JNI_TRUE; + options.show_stats = show_stats == JNI_TRUE; + options.predict_ms = predict_ms; + options.dynamic_resolution = dynamic_resolution != 0; + options.follow_layer_size = dynamic_resolution == 2; + options.cpu_boost = cpu_boost == JNI_TRUE; + g_app->xr_thread = std::thread{[options] { + App& app = *g_app; + JNIEnv* thread_env = nullptr; + app.vm->AttachCurrentThread(&thread_env, nullptr); + // This thread has little to do, but it has to do it every refresh: it must not wait + // for the emulator's threads, which outnumber the processor cores. + ::setpriority(PRIO_PROCESS, 0, -16); + RunXrHost(app.vm, app.activity, app.core, app.status, options, app.xr_status, app.quit, + app.recenter_requests); + LOGI("XR thread finished"); + if (!app.quit) { + // The system ended the session (the user quit from its menu), or there never was + // one: without a headset to show it in there is no point in the game running on. + const jclass activity_class = thread_env->GetObjectClass(app.activity); + const jmethodID ended = + thread_env->GetMethodID(activity_class, "onSessionEnded", "()V"); + if (ended != nullptr) { + thread_env->CallVoidMethod(app.activity, ended); + } + if (thread_env->ExceptionCheck()) { + thread_env->ExceptionClear(); + } + } + app.vm->DetachCurrentThread(); + }}; +} + +JNIEXPORT jboolean JNICALL Java_com_astrobotquest_vrhost_MainActivity_nativeStartCore( + JNIEnv* env, jobject, jstring loader, jstring runtime_root, jstring storage_root, jstring game, + jstring log_file, jobjectArray extra_args, jobjectArray extra_env) { + if (!g_app) { + return JNI_FALSE; + } + CoreLaunch launch; + launch.loader = ToString(env, loader); + launch.runtime_root = ToString(env, runtime_root); + launch.storage_root = ToString(env, storage_root); + launch.game = ToString(env, game); + launch.log_file = ToString(env, log_file); + launch.extra_args = ToStrings(env, extra_args); + // NAME=value pairs. + for (const std::string& entry : ToStrings(env, extra_env)) { + const size_t equals = entry.find('='); + if (equals != std::string::npos && equals > 0) { + launch.extra_env.emplace_back(entry.substr(0, equals), entry.substr(equals + 1)); + } + } + return g_app->core.Start(launch) ? JNI_TRUE : JNI_FALSE; +} + +JNIEXPORT void JNICALL Java_com_astrobotquest_vrhost_MainActivity_nativeStop(JNIEnv* env, jobject) { + if (!g_app) { + return; + } + g_app->quit = true; + g_app->core.Stop(); + if (g_app->xr_thread.joinable()) { + g_app->xr_thread.join(); + } + env->DeleteGlobalRef(g_app->activity); + g_app.reset(); +} + +JNIEXPORT jint JNICALL Java_com_astrobotquest_vrhost_MainActivity_nativeCoreState(JNIEnv*, + jobject) { + return g_app ? static_cast<jint>(g_app->core.GetState()) : 0; +} + +JNIEXPORT jstring JNICALL Java_com_astrobotquest_vrhost_MainActivity_nativeCoreMessage(JNIEnv* env, + jobject) { + return env->NewStringUTF(g_app ? g_app->core.GetMessage().c_str() : ""); +} + +JNIEXPORT jlong JNICALL Java_com_astrobotquest_vrhost_MainActivity_nativeFrameCount(JNIEnv*, + jobject) { + return g_app ? static_cast<jlong>(g_app->core.GetPresentedFrames()) : 0; +} + +/// `pixels` is a direct buffer of StatusImage::Width x Height RGBA pixels, top row first. +JNIEXPORT void JNICALL Java_com_astrobotquest_vrhost_MainActivity_nativeSetStatusImage( + JNIEnv* env, jobject, jobject pixels) { + if (!g_app) { + return; + } + const auto* data = static_cast<const uint8_t*>(env->GetDirectBufferAddress(pixels)); + const jlong size = env->GetDirectBufferCapacity(pixels); + const jlong expected = jlong{StatusImage::Width} * StatusImage::Height * 4; + if (data == nullptr || size < expected) { + return; + } + std::scoped_lock lock{g_app->status.mutex}; + g_app->status.pixels.assign(data, data + expected); + ++g_app->status.version; +} + +JNIEXPORT void JNICALL Java_com_astrobotquest_vrhost_MainActivity_nativeInput( + JNIEnv*, jobject, jint buttons, jint left_x, jint left_y, jint right_x, jint right_y, + jint left_trigger, jint right_trigger, jboolean touch_down, jint touch_x, jint touch_y) { + if (!g_app) { + return; + } + std::scoped_lock lock{g_app->pad_mutex}; + PadState& pad = g_app->pad; + pad.buttons = static_cast<uint32_t>(buttons); + pad.left_x = static_cast<uint8_t>(left_x); + pad.left_y = static_cast<uint8_t>(left_y); + pad.right_x = static_cast<uint8_t>(right_x); + pad.right_y = static_cast<uint8_t>(right_y); + pad.left_trigger = static_cast<uint8_t>(left_trigger); + pad.right_trigger = static_cast<uint8_t>(right_trigger); + pad.touch_down = touch_down == JNI_TRUE; + pad.touch_x = static_cast<uint16_t>(touch_x); + pad.touch_y = static_cast<uint16_t>(touch_y); + g_app->core.SetPad(pad); +} + +/// Gyroscope in rad/s and accelerometer in m/s², in the controller's frame. +JNIEXPORT void JNICALL Java_com_astrobotquest_vrhost_MainActivity_nativeMotion( + JNIEnv*, jobject, jfloat gx, jfloat gy, jfloat gz, jfloat ax, jfloat ay, jfloat az) { + if (!g_app) { + return; + } + std::scoped_lock lock{g_app->pad_mutex}; + PadState& pad = g_app->pad; + pad.has_motion = true; + pad.gyro[0] = gx; + pad.gyro[1] = gy; + pad.gyro[2] = gz; + pad.accel[0] = ax; + pad.accel[1] = ay; + pad.accel[2] = az; + g_app->core.SetPad(pad); +} + +/// What the game asks of the controller: see CoreProcess::GetPadFeedback for the layout. +JNIEXPORT jlong JNICALL Java_com_astrobotquest_vrhost_MainActivity_nativePadFeedback(JNIEnv*, + jobject) { + return g_app ? static_cast<jlong>(g_app->core.GetPadFeedback()) : 0; +} + +/// The player asks for the view to be reset (see XrRecenter in xr_host.h for what of it). +JNIEXPORT void JNICALL Java_com_astrobotquest_vrhost_MainActivity_nativeRecenter(JNIEnv*, jobject, + jint what) { + if (g_app) { + g_app->recenter_requests.fetch_or(static_cast<uint32_t>(what)); + } +} + +JNIEXPORT void JNICALL Java_com_astrobotquest_vrhost_MainActivity_nativeSetMicrophone( + JNIEnv*, jobject, jboolean enabled, jfloat gain) { + if (g_app) { + g_app->core.SetMicrophone(enabled == JNI_TRUE, gain); + } +} + +JNIEXPORT void JNICALL Java_com_astrobotquest_vrhost_MainActivity_nativeSetLogFile(JNIEnv* env, + jclass, + jstring path) { + SetLogFile(ToString(env, path).c_str()); +} + +JNIEXPORT void JNICALL Java_com_astrobotquest_vrhost_MainActivity_nativeLog(JNIEnv* env, jclass, + jint priority, + jstring message) { + HostLog(priority, "%s", ToString(env, message).c_str()); +} + +/// Bit 0: the headset session is running. Bit 1: the hands holding the controller are seen. +/// Bits 8 to 15: the display's refresh rate in Hz. +JNIEXPORT jint JNICALL Java_com_astrobotquest_vrhost_MainActivity_nativeXrStatus(JNIEnv*, + jobject) { + if (!g_app) { + return 0; + } + const int refresh_rate = + std::clamp(static_cast<int>(g_app->xr_status.refresh_rate.load() + 0.5f), 0, 255); + return (g_app->xr_status.session_running ? 1 : 0) | (g_app->xr_status.hands_tracked ? 2 : 0) | + (refresh_rate << 8); +} + +} // extern "C" diff --git a/quest-host/cpp/self_test.cpp b/quest-host/cpp/self_test.cpp new file mode 100644 index 0000000..8b75486 --- /dev/null +++ b/quest-host/cpp/self_test.cpp @@ -0,0 +1,550 @@ +// SPDX-License-Identifier: GPL-2.0-or-later + +// Everything the host does with the emulator core except showing the result in the headset: +// starting it, the control socket (controller input), the frame buffers it shares with the core +// and the GL path that reads them. It runs from the SandboxShell instrumentation, so it needs +// nobody wearing the headset, and leaves pictures of what a headset would have been shown. + +#include <atomic> +#include <chrono> +#include <cmath> +#include <cstdio> +#include <cstdlib> +#include <cstring> +#include <string> +#include <thread> +#include <vector> + +#include <jni.h> +#include <sys/stat.h> +#include <zlib.h> + +#include "core_process.h" +#include "gl_frames.h" +#include "log.h" + +namespace Protocol = Core::Vr::Protocol; + +namespace { + +void AppendChunk(std::vector<uint8_t>& png, const char* type, const uint8_t* data, size_t size) { + const auto put32 = [&](uint32_t value) { + for (int shift = 24; shift >= 0; shift -= 8) { + png.push_back(static_cast<uint8_t>(value >> shift)); + } + }; + put32(static_cast<uint32_t>(size)); + const size_t start = png.size(); + png.insert(png.end(), type, type + 4); + png.insert(png.end(), data, data + size); + put32(static_cast<uint32_t>(crc32(0, png.data() + start, static_cast<uInt>(4 + size)))); +} + +/// Writes RGBA pixels whose first row is the bottom one (as glReadPixels returns them) as an +/// opaque PNG, at half size: these are for looking at, not for measuring. +bool WritePng(const std::string& path, const std::vector<uint8_t>& rgba, uint32_t width, + uint32_t height) { + const uint32_t out_width = width / 2; + const uint32_t out_height = height / 2; + std::vector<uint8_t> raw; + raw.reserve(static_cast<size_t>(out_height) * (1 + out_width * 3)); + for (uint32_t y = 0; y < out_height; ++y) { + raw.push_back(0); // filter: none + const uint8_t* upper = rgba.data() + static_cast<size_t>(height - 1 - 2 * y) * width * 4; + const uint8_t* lower = upper - static_cast<size_t>(width) * 4; + for (uint32_t x = 0; x < out_width; ++x) { + for (int channel = 0; channel < 3; ++channel) { + const uint32_t sum = upper[x * 8 + channel] + upper[x * 8 + 4 + channel] + + lower[x * 8 + channel] + lower[x * 8 + 4 + channel]; + raw.push_back(static_cast<uint8_t>(sum / 4)); + } + } + } + uLongf compressed_size = compressBound(static_cast<uLong>(raw.size())); + std::vector<uint8_t> compressed(compressed_size); + if (compress2(compressed.data(), &compressed_size, raw.data(), static_cast<uLong>(raw.size()), + 3) != Z_OK) { + return false; + } + + std::vector<uint8_t> png = {0x89, 'P', 'N', 'G', 0x0d, 0x0a, 0x1a, 0x0a}; + uint8_t header[13] = {}; + for (int i = 0; i < 4; ++i) { + header[i] = static_cast<uint8_t>(out_width >> (24 - 8 * i)); + header[4 + i] = static_cast<uint8_t>(out_height >> (24 - 8 * i)); + } + header[8] = 8; // bits per channel + header[9] = 2; // RGB + AppendChunk(png, "IHDR", header, sizeof(header)); + AppendChunk(png, "IDAT", compressed.data(), compressed_size); + AppendChunk(png, "IEND", nullptr, 0); + + std::FILE* file = std::fopen(path.c_str(), "wb"); + if (file == nullptr) { + return false; + } + const bool ok = std::fwrite(png.data(), 1, png.size(), file) == png.size(); + std::fclose(file); + return ok; +} + +/// Stands in for the headset's compositor, which takes the GPU away from the emulator several +/// times every display refresh: a context of its own that, so many times a second, draws and +/// waits for the GPU to be done with it. Among the settings: +/// HOST_INTERRUPTS=<per second> next to nothing is drawn each time +/// HOST_COMPOSITOR=<Hz>[,<n>[,<Mpx>]] per refresh, a pass the size of the compositor's own +/// (9 megapixels unless told otherwise) and n - 1 times +/// next to nothing (n is 5 unless told otherwise: what +/// a session shows, with one layer and nothing else of +/// the system on screen) +class Interrupter { +public: + ~Interrupter() { + Stop(); + } + + void Start(const GlContext& main, int refreshes, int per_refresh, float megapixels) { + if (refreshes > 0 && per_refresh > 0) { + thread = std::thread{[this, display = main.display, config = main.config, refreshes, + per_refresh, + megapixels] { Run(display, config, refreshes, per_refresh, megapixels); }}; + } + } + + void Stop() { + quit = true; + if (thread.joinable()) { + thread.join(); + } + } + + uint64_t Count() const { + return count; + } + + /// Milliseconds the large passes took on average since the last call. + float TakePassTime() { + const uint64_t passes = pass_count.exchange(0); + const uint64_t time = pass_microseconds.exchange(0); + return passes != 0 ? static_cast<float>(time) / static_cast<float>(passes) / 1000.0f : 0.0f; + } + +private: + void Run(EGLDisplay display, EGLConfig config, int refreshes, int per_refresh, + float megapixels) { + using Clock = std::chrono::steady_clock; + const EGLint context_attributes[] = {EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE}; + const EGLContext context = + eglCreateContext(display, config, EGL_NO_CONTEXT, context_attributes); + const EGLint surface_attributes[] = {EGL_WIDTH, 16, EGL_HEIGHT, 16, EGL_NONE}; + const EGLSurface surface = eglCreatePbufferSurface(display, config, surface_attributes); + if (context == EGL_NO_CONTEXT || surface == EGL_NO_SURFACE || + !eglMakeCurrent(display, surface, surface, context)) { + LOGE("self test: no context for the interruptions"); + return; + } + const auto make_target = [](GLsizei width, GLsizei height, GLuint& texture, + GLuint& framebuffer) { + glGenTextures(1, &texture); + glBindTexture(GL_TEXTURE_2D, texture); + glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, width, height); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glGenFramebuffers(1, &framebuffer); + glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, + 0); + }; + GLuint small = 0; + GLuint small_framebuffer = 0; + make_target(64, 64, small, small_framebuffer); + // The compositor's pass: the game's picture, both eyes, drawn to the display's size. + GLuint source = 0; + GLuint source_framebuffer = 0; + GLuint large = 0; + GLuint large_framebuffer = 0; + FrameBlitter blitter; + const auto large_height = static_cast<GLsizei>(std::sqrt(megapixels * 1e6f / 1.87f)); + const auto large_width = static_cast<GLsizei>(static_cast<float>(large_height) * 1.87f); + if (megapixels > 0.0f) { + make_target(2880, 1536, source, source_framebuffer); + make_target(large_width, large_height, large, large_framebuffer); + blitter.Create(); + } + + const auto period = std::chrono::nanoseconds{1'000'000'000LL / refreshes}; + auto refresh = Clock::now(); + while (!quit) { + for (int i = 0; i < per_refresh && !quit; ++i) { + if (i == 0 && megapixels > 0.0f) { + const auto begun = Clock::now(); + glBindFramebuffer(GL_FRAMEBUFFER, large_framebuffer); + blitter.Draw(source, static_cast<uint32_t>(large_width), + static_cast<uint32_t>(large_height), false, false); + glFinish(); + pass_microseconds += static_cast<uint64_t>( + std::chrono::duration_cast<std::chrono::microseconds>(Clock::now() - begun) + .count()); + ++pass_count; + } else { + glBindFramebuffer(GL_FRAMEBUFFER, small_framebuffer); + glClearColor(0.0f, static_cast<float>(count % 2), 0.0f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT); + glFinish(); + } + ++count; + std::this_thread::sleep_until(refresh + period * (i + 1) / per_refresh); + } + refresh += period; + } + if (megapixels > 0.0f) { + blitter.Destroy(); + } + eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); + eglDestroySurface(display, surface); + eglDestroyContext(display, context); + } + + std::thread thread; + std::atomic<bool> quit{false}; + std::atomic<uint64_t> count{0}; + std::atomic<uint64_t> pass_count{0}; + std::atomic<uint64_t> pass_microseconds{0}; +}; + +std::string ToString(JNIEnv* env, jstring text) { + if (text == nullptr) { + return {}; + } + const char* chars = env->GetStringUTFChars(text, nullptr); + std::string result{chars != nullptr ? chars : ""}; + env->ReleaseStringUTFChars(text, chars); + return result; +} + +std::string RunSelfTest(const CoreLaunch& launch, const std::string& out_dir, int seconds, + uint32_t eye_width, uint32_t eye_height, const std::string& microphone) { + using Clock = std::chrono::steady_clock; + const uint32_t width = eye_width * 2; + const uint32_t height = eye_height; + std::string report; + const auto note = [&](const char* format, auto... values) { + char line[512]; + std::snprintf(line, sizeof(line), format, values...); + LOGI("self test: %s", line); + report += line; + report += '\n'; + }; + + ::mkdir(out_dir.c_str(), 0700); + SetLogFile((out_dir + "/host.log").c_str()); + GlContext gl; + if (!gl.Create()) { + return "no GL context\n"; + } + note("GL: %s", reinterpret_cast<const char*>(glGetString(GL_RENDERER))); + + CoreProcess core; + FrameBuffers frames; + FrameBlitter blitter; + // "real" listens to the headset (which hears nothing while nobody wears it, but the path + // is the one a session takes), "off" to nothing, anything else to the test signal. + core.SetMicrophone(microphone != "off", 1.0f, microphone != "real"); + if (!core.Start(launch)) { + gl.Destroy(); + return report + "the core did not start: " + core.GetMessage() + "\n"; + } + if (!frames.Create(gl.display, width, height, core) || !blitter.Create()) { + core.Stop(); + gl.Destroy(); + return report + "could not create the frame buffers\n"; + } + + // Stands in for the compositor's image the frame is copied to. + GLuint target = 0; + GLuint framebuffer = 0; + glGenTextures(1, &target); + glBindTexture(GL_TEXTURE_2D, target); + glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, static_cast<GLsizei>(width), + static_cast<GLsizei>(height)); + glGenFramebuffers(1, &framebuffer); + glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, target, 0); + if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) { + note("%s", "the test framebuffer is incomplete"); + } + // And one of the kind the compositor's images are, for timing the copy a session makes. + GLuint display_target = 0; + GLuint display_framebuffer = 0; + glGenTextures(1, &display_target); + glBindTexture(GL_TEXTURE_2D, display_target); + glTexStorage2D(GL_TEXTURE_2D, 1, GL_SRGB8_ALPHA8, static_cast<GLsizei>(width), + static_cast<GLsizei>(height)); + glGenFramebuffers(1, &display_framebuffer); + glBindFramebuffer(GL_FRAMEBUFFER, display_framebuffer); + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, display_target, + 0); + note("frames are copied %s", blitter.WritesUnencoded() ? "as they are" : "through a decoder"); + + Interrupter interrupter; + for (const auto& [name, value] : launch.extra_env) { + if (name == "HOST_INTERRUPTS") { + interrupter.Start(gl, std::atoi(value.c_str()), 1, 0.0f); + note("taking the GPU away from the emulator %s times a second", value.c_str()); + } else if (name == "HOST_COMPOSITOR") { + int refreshes = 0; + int per_refresh = 5; + float megapixels = 9.0f; + std::sscanf(value.c_str(), "%d,%d,%f", &refreshes, &per_refresh, &megapixels); + interrupter.Start(gl, refreshes, per_refresh, megapixels); + note("a stand-in for the compositor: %d refreshes a second, the GPU taken %d times " + "in each, once for a pass of %.1f megapixels", + refreshes, per_refresh, megapixels); + } + } + uint64_t reported_interruptions = 0; + bool view_reset = false; + + // HOST_DISPLAY=<Hz> among the settings: the loop below goes round once for every refresh + // of a display of that rate, the way a session's does, tells the emulator of each, and + // counts for how many refreshes each of the game's frames stayed the newest (a game that + // draws one frame for two refreshes should have every frame shown for two). + float display_rate = 0.0f; + for (const auto& [name, value] : launch.extra_env) { + if (name == "HOST_DISPLAY") { + display_rate = std::strtof(value.c_str(), nullptr); + note("a display of %.2f refreshes a second", display_rate); + } + } + uint32_t shown_for[5]{}; + uint32_t shown_since = 0; + bool something_shown = false; + + // HOST_LOOK="<from second>:<degrees left>,<degrees up>;..." among the settings: where the + // head looks from when on, in place of its swaying. "8:85,22;100:0,-12" finds the first + // level of Astro Bot from the world map (the planets are picked by looking at them) and + // then looks along it. + struct Look { + float from; + float yaw; + float pitch; + }; + std::vector<Look> looks; + for (const auto& [name, value] : launch.extra_env) { + if (name != "HOST_LOOK") { + continue; + } + size_t at = 0; + while (at < value.size()) { + const size_t end = std::min(value.find(';', at), value.size()); + Look look{}; + if (std::sscanf(value.substr(at, end - at).c_str(), "%f:%f,%f", &look.from, &look.yaw, + &look.pitch) == 3) { + looks.push_back(look); + } + at = end + 1; + } + note("the head follows %zu looks", looks.size()); + } + + const auto start = Clock::now(); + const auto seconds_since_start = [&] { + return std::chrono::duration<float>(Clock::now() - start).count(); + }; + uint32_t received = 0; + uint32_t saved = 0; + uint32_t last_frame_id = 0; + uint32_t interval_frames = 0; + float first_frame_at = -1.0f; + float next_save_at = 0.0f; + float interval_start = 0.0f; + double reported_cpu_seconds = 0.0; + float copy_ms = 0.0f; + float worst_copy_ms = 0.0f; + uint32_t copies = 0; + std::vector<uint8_t> pixels(static_cast<size_t>(width) * height * 4); + std::thread writer; + + auto next_refresh = Clock::now(); + for (uint32_t tick = 0; seconds_since_start() < static_cast<float>(seconds); ++tick) { + if (display_rate > 0.0f) { + core.SendRefresh(display_rate); + } + const float now = seconds_since_start(); + const auto state = core.GetState(); + if (state == CoreProcess::State::Failed || state == CoreProcess::State::Stopped) { + note("the core ended after %.1f s: %s", now, core.GetMessage().c_str()); + break; + } + + // A head that looks slowly left and right, the way a compositor reports it, or + // where it was told to look. + float yaw = 0.35f * std::sin(now * 0.8f); + float pitch = 0.0f; + Protocol::Pose pose; + if (looks.empty()) { + pose.angular_velocity[1] = 0.35f * 0.8f * std::cos(now * 0.8f); + } else { + yaw = 0.0f; + for (const Look& look : looks) { + if (now >= look.from) { + yaw = look.yaw / 57.29578f; + pitch = look.pitch / 57.29578f; + } + } + } + pose.orientation[0] = std::cos(yaw * 0.5f) * std::sin(pitch * 0.5f); + pose.orientation[1] = std::sin(yaw * 0.5f) * std::cos(pitch * 0.5f); + pose.orientation[2] = -std::sin(yaw * 0.5f) * std::sin(pitch * 0.5f); + pose.orientation[3] = std::cos(yaw * 0.5f) * std::cos(pitch * 0.5f); + core.SendPose(pose); + if (tick % 300 == 0) { + core.SendOptics(0.064f); + } + // Once, mid-sway: the player asks for the view to be reset (the emulator's log says + // where it then takes the seat to be). + if (!view_reset && looks.empty() && now > 33.0f) { + view_reset = true; + Protocol::PadPose reset; + reset.flags = Protocol::PadPose::RecenterSeat; + core.SendPadPose(reset); + note("view reset asked for with the head turned %.0f degrees", yaw * 57.29578f); + } + + // Cross for a quarter of every five seconds gets a title past its menus. + PadState pad; + pad.buttons = std::fmod(now, 5.0f) < 0.25f && now > 20.0f ? 0x4000u : 0u; + core.SetPad(pad); + + ++shown_since; + if (const auto frame = core.TakeFrame()) { + if (something_shown) { + ++shown_for[std::min<uint32_t>(shown_since, 4)]; + } + something_shown = true; + shown_since = 0; + ++received; + ++interval_frames; + last_frame_id = frame->frame_id; + if (first_frame_at < 0.0f) { + first_frame_at = now; + note("first frame after %.1f s: buffer %u, eye %ux%u, fov tan %.3f/%.3f/%.3f/%.3f", + now, frame->buffer, frame->eye_width, frame->eye_height, frame->fov[0], + frame->fov[1], frame->fov[2], frame->fov[3]); + } + if (frames.IsValid(frame->buffer)) { + // What a headset session does with every frame, timed until the GPU is done + // with it: the copy has to get its turn on a GPU the emulator keeps busy, and + // the session's frame loop goes no faster than that. + const auto begun = Clock::now(); + glBindFramebuffer(GL_FRAMEBUFFER, display_framebuffer); + blitter.Draw(frames.Texture(frame->buffer), width, height, + frame->swap_red_blue != 0, true); + const GLsync done = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0); + glClientWaitSync(done, GL_SYNC_FLUSH_COMMANDS_BIT, 2'000'000'000); + glDeleteSync(done); + const float took = + std::chrono::duration<float, std::milli>(Clock::now() - begun).count(); + copy_ms += took; + worst_copy_ms = std::max(worst_copy_ms, took); + ++copies; + } + if (frames.IsValid(frame->buffer) && now >= next_save_at && saved < 24) { + glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); + blitter.Draw(frames.Texture(frame->buffer), width, height, + frame->swap_red_blue != 0, false); + glReadPixels(0, 0, static_cast<GLsizei>(width), static_cast<GLsizei>(height), + GL_RGBA, GL_UNSIGNED_BYTE, pixels.data()); + char name[64]; + std::snprintf(name, sizeof(name), "/frame_%03u_%05u.png", saved, frame->frame_id); + // Packing the picture takes many refreshes of the display this loop stands in + // for: that is done beside it. + if (writer.joinable()) { + writer.join(); + } + writer = std::thread{[path = out_dir + name, copy = pixels, width, height] { + WritePng(path, copy, width, height); + }}; + ++saved; + next_save_at = now + 10.0f; + } + } + if (now - interval_start >= 10.0f) { + const CoreProcess::Usage usage = core.GetUsage(); + note("%.0f s: %u frames, %.1f per second; emulator %.0f%% of a processor on %s, %d MB; " + "copying a frame took %.1f ms, %.1f at worst", + now, received, static_cast<float>(interval_frames) / (now - interval_start), + (usage.cpu_seconds - reported_cpu_seconds) * 100.0 / (now - interval_start), + usage.cpus.c_str(), usage.memory_mb, + copies != 0 ? copy_ms / static_cast<float>(copies) : 0.0f, worst_copy_ms); + if (const uint64_t interruptions = interrupter.Count(); interruptions != 0) { + note(" %.0f interruptions a second, the large pass took %.2f ms", + static_cast<float>(interruptions - reported_interruptions) / + (now - interval_start), + interrupter.TakePassTime()); + reported_interruptions = interruptions; + } + if (display_rate > 0.0f) { + note(" frames shown for one refresh: %u, for two: %u, for three: %u, for " + "more: %u", + shown_for[1], shown_for[2], shown_for[3], shown_for[4]); + std::fill(std::begin(shown_for), std::end(shown_for), 0u); + } + reported_cpu_seconds = usage.cpu_seconds; + interval_start = now; + interval_frames = 0; + copy_ms = 0.0f; + worst_copy_ms = 0.0f; + copies = 0; + } + if (display_rate > 0.0f) { + next_refresh += std::chrono::nanoseconds{static_cast<int64_t>(1e9f / display_rate)}; + std::this_thread::sleep_until(next_refresh); + } else { + std::this_thread::sleep_for(std::chrono::milliseconds{5}); + } + } + + if (writer.joinable()) { + writer.join(); + } + note("%u frames received (last id %u), %u pictures in %s, GL error 0x%x", received, + last_frame_id, saved, out_dir.c_str(), glGetError()); + interrupter.Stop(); + core.Stop(); + glDeleteFramebuffers(1, &framebuffer); + glDeleteTextures(1, &target); + glDeleteFramebuffers(1, &display_framebuffer); + glDeleteTextures(1, &display_target); + blitter.Destroy(); + frames.Destroy(gl.display); + gl.Destroy(); + return report; +} + +} // namespace + +extern "C" JNIEXPORT jstring JNICALL Java_com_astrobotquest_vrhost_SandboxShell_nativeSelfTest( + JNIEnv* env, jclass, jstring loader, jstring runtime_root, jstring storage_root, jstring game, + jstring log_file, jstring out_dir, jint seconds, jobjectArray extra_env, jstring microphone) { + CoreLaunch launch; + launch.loader = ToString(env, loader); + launch.runtime_root = ToString(env, runtime_root); + launch.storage_root = ToString(env, storage_root); + launch.game = ToString(env, game); + launch.log_file = ToString(env, log_file); + const jsize count = extra_env != nullptr ? env->GetArrayLength(extra_env) : 0; + for (jsize i = 0; i < count; ++i) { + const auto element = static_cast<jstring>(env->GetObjectArrayElement(extra_env, i)); + const std::string entry = ToString(env, element); + env->DeleteLocalRef(element); + const size_t equals = entry.find('='); + if (equals != std::string::npos && equals > 0) { + launch.extra_env.emplace_back(entry.substr(0, equals), entry.substr(equals + 1)); + } + } + const std::string report = + RunSelfTest(launch, ToString(env, out_dir), seconds, 1440, 1536, + ToString(env, microphone)); + return env->NewStringUTF(report.c_str()); +} diff --git a/quest-host/cpp/xr_host.cpp b/quest-host/cpp/xr_host.cpp new file mode 100644 index 0000000..bb5b3dc --- /dev/null +++ b/quest-host/cpp/xr_host.cpp @@ -0,0 +1,1448 @@ +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "xr_host.h" + +#include <algorithm> +#include <chrono> +#include <cmath> +#include <cstdio> +#include <cstdlib> +#include <cstring> +#include <ctime> +#include <iterator> +#include <optional> +#include <string> +#include <vector> + +#include <sys/wait.h> +#include <unistd.h> + +#include "gl_frames.h" + +#define XR_USE_PLATFORM_ANDROID +#define XR_USE_GRAPHICS_API_OPENGL_ES +#define XR_USE_TIMESPEC +#include <openxr/openxr.h> +#include <openxr/openxr_platform.h> + +#include "core_process.h" +#include "log.h" + +namespace Protocol = Core::Vr::Protocol; + +namespace { + +constexpr int64_t FormatSrgb8Alpha8 = 0x8C43; // GL_SRGB8_ALPHA8 +constexpr int64_t FormatRgba8 = 0x8058; // GL_RGBA8 + +bool Check(XrResult result, const char* what) { + if (XR_FAILED(result)) { + LOGE("%s failed: %d", what, static_cast<int>(result)); + return false; + } + return true; +} + +template <typename Function> +Function GetFunction(XrInstance instance, const char* name) { + PFN_xrVoidFunction function = nullptr; + xrGetInstanceProcAddr(instance, name, &function); + return reinterpret_cast<Function>(function); +} + +const char* SessionStateName(XrSessionState state) { + switch (state) { + case XR_SESSION_STATE_IDLE: + return "idle"; + case XR_SESSION_STATE_READY: + return "ready"; + case XR_SESSION_STATE_SYNCHRONIZED: + return "synchronized"; + case XR_SESSION_STATE_VISIBLE: + return "visible"; + case XR_SESSION_STATE_FOCUSED: + return "focused"; + case XR_SESSION_STATE_STOPPING: + return "stopping"; + case XR_SESSION_STATE_LOSS_PENDING: + return "loss pending"; + case XR_SESSION_STATE_EXITING: + return "exiting"; + default: + return "unknown"; + } +} + +XrVector3f Rotate(const XrQuaternionf& q, const XrVector3f& v) { + const XrVector3f u{q.x, q.y, q.z}; + const XrVector3f t{ + u.y * v.z - u.z * v.y + q.w * v.x, + u.z * v.x - u.x * v.z + q.w * v.y, + u.x * v.y - u.y * v.x + q.w * v.z, + }; + return { + v.x + 2.0f * (u.y * t.z - u.z * t.y), + v.y + 2.0f * (u.z * t.x - u.x * t.z), + v.z + 2.0f * (u.x * t.y - u.y * t.x), + }; +} + +struct Swapchain { + XrSwapchain handle{XR_NULL_HANDLE}; + uint32_t width{}; + uint32_t height{}; + std::vector<XrSwapchainImageOpenGLESKHR> images; + std::vector<GLuint> framebuffers; +}; + +class Host { +public: + Host(JavaVM* vm_, jobject activity_, CoreProcess& core_, StatusImage& status_, + const XrHostOptions& options_, XrHostStatus& host_status_, std::atomic<bool>& quit_, + std::atomic<uint32_t>& recenter_requests_) + : vm{vm_}, activity{activity_}, core{core_}, status{status_}, options{options_}, + host_status{host_status_}, quit{quit_}, recenter_requests{recenter_requests_} {} + + void Run() { + if (gl.Create() && InitOpenXr() && InitRendering()) { + Loop(); + } else { + LOGE("the headset session could not be set up"); + } + Shutdown(); + } + +private: + bool InitOpenXr() { + const auto initialize_loader = + GetFunction<PFN_xrInitializeLoaderKHR>(XR_NULL_HANDLE, "xrInitializeLoaderKHR"); + if (initialize_loader == nullptr) { + LOGE("the OpenXR loader has no xrInitializeLoaderKHR"); + return false; + } + XrLoaderInitInfoAndroidKHR loader_info{XR_TYPE_LOADER_INIT_INFO_ANDROID_KHR}; + loader_info.applicationVM = vm; + loader_info.applicationContext = activity; + if (!Check(initialize_loader( + reinterpret_cast<const XrLoaderInitInfoBaseHeaderKHR*>(&loader_info)), + "xrInitializeLoaderKHR")) { + return false; + } + + uint32_t count = 0; + xrEnumerateInstanceExtensionProperties(nullptr, 0, &count, nullptr); + std::vector<XrExtensionProperties> available(count, {XR_TYPE_EXTENSION_PROPERTIES}); + xrEnumerateInstanceExtensionProperties(nullptr, count, &count, available.data()); + const auto has = [&](const char* name) { + return std::any_of(available.begin(), available.end(), [&](const auto& property) { + return std::strcmp(property.extensionName, name) == 0; + }); + }; + + std::vector<const char*> extensions = { + XR_KHR_ANDROID_CREATE_INSTANCE_EXTENSION_NAME, + XR_KHR_OPENGL_ES_ENABLE_EXTENSION_NAME, + }; + const auto enable_if_present = [&](const char* name) { + const bool present = has(name); + if (present) { + extensions.push_back(name); + } + return present; + }; + has_refresh_rate = enable_if_present(XR_FB_DISPLAY_REFRESH_RATE_EXTENSION_NAME); + has_performance = enable_if_present(XR_EXT_PERFORMANCE_SETTINGS_EXTENSION_NAME); + has_thread_settings = enable_if_present(XR_KHR_ANDROID_THREAD_SETTINGS_EXTENSION_NAME); + has_layer_settings = options.sharpen >= 2 && + enable_if_present(XR_FB_COMPOSITION_LAYER_SETTINGS_EXTENSION_NAME); + // Lets the system drop the sharpening while the GPU has nothing to spare for it. With + // an emulator on the same GPU that is nearly always: in a level of the game the filter + // was off two thirds of the time, which is why it is only left to the system on request. + has_auto_filter = has_layer_settings && options.sharpen == 3 && + enable_if_present(XR_META_AUTOMATIC_LAYER_FILTER_EXTENSION_NAME); + has_swapchain_state = + options.cubic && enable_if_present(XR_FB_SWAPCHAIN_UPDATE_STATE_EXTENSION_NAME) && + enable_if_present(XR_FB_SWAPCHAIN_UPDATE_STATE_OPENGL_ES_EXTENSION_NAME); + has_hand_tracking = + options.track_hands && enable_if_present(XR_EXT_HAND_TRACKING_EXTENSION_NAME); + has_layer_resolution = + options.dynamic_resolution && + enable_if_present(XR_META_RECOMMENDED_LAYER_RESOLUTION_EXTENSION_NAME); + has_metrics = enable_if_present(XR_META_PERFORMANCE_METRICS_EXTENSION_NAME); + // Only the probe needs a time without a frame to take it from. + has_time_conversion = + options.probe && enable_if_present(XR_KHR_CONVERT_TIMESPEC_TIME_EXTENSION_NAME); + + XrInstanceCreateInfoAndroidKHR android_info{XR_TYPE_INSTANCE_CREATE_INFO_ANDROID_KHR}; + android_info.applicationVM = vm; + android_info.applicationActivity = activity; + XrInstanceCreateInfo instance_info{XR_TYPE_INSTANCE_CREATE_INFO}; + instance_info.next = &android_info; + std::strcpy(instance_info.applicationInfo.applicationName, "Astro VR Host"); + instance_info.applicationInfo.applicationVersion = 1; + instance_info.applicationInfo.apiVersion = XR_API_VERSION_1_0; + instance_info.enabledExtensionCount = static_cast<uint32_t>(extensions.size()); + instance_info.enabledExtensionNames = extensions.data(); + if (!Check(xrCreateInstance(&instance_info, &instance), "xrCreateInstance")) { + return false; + } + + XrSystemGetInfo system_info{XR_TYPE_SYSTEM_GET_INFO}; + system_info.formFactor = XR_FORM_FACTOR_HEAD_MOUNTED_DISPLAY; + if (!Check(xrGetSystem(instance, &system_info, &system), "xrGetSystem")) { + return false; + } + XrSystemHandTrackingPropertiesEXT hand_properties{ + XR_TYPE_SYSTEM_HAND_TRACKING_PROPERTIES_EXT}; + XrSystemProperties system_properties{XR_TYPE_SYSTEM_PROPERTIES}; + if (has_hand_tracking) { + system_properties.next = &hand_properties; + } + xrGetSystemProperties(instance, system, &system_properties); + max_swapchain_width = system_properties.graphicsProperties.maxSwapchainImageWidth; + has_hand_tracking = has_hand_tracking && hand_properties.supportsHandTracking == XR_TRUE; + LOGI("OpenXR system: %s, max swapchain %ux%u, hand tracking %d, layer filters %d (left " + "to the system %d), cubic sampling %d, recommended layer size %d", + system_properties.systemName, max_swapchain_width, + system_properties.graphicsProperties.maxSwapchainImageHeight, has_hand_tracking, + has_layer_settings, has_auto_filter, has_swapchain_state, has_layer_resolution); + if (has_layer_resolution) { + get_layer_resolution = GetFunction<PFN_xrGetRecommendedLayerResolutionMETA>( + instance, "xrGetRecommendedLayerResolutionMETA"); + } + + // The runtime insists on being asked this before a session is created. + const auto get_requirements = GetFunction<PFN_xrGetOpenGLESGraphicsRequirementsKHR>( + instance, "xrGetOpenGLESGraphicsRequirementsKHR"); + XrGraphicsRequirementsOpenGLESKHR requirements{XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_ES_KHR}; + if (get_requirements == nullptr || + !Check(get_requirements(instance, system, &requirements), + "xrGetOpenGLESGraphicsRequirementsKHR")) { + return false; + } + + XrGraphicsBindingOpenGLESAndroidKHR binding{XR_TYPE_GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR}; + binding.display = gl.display; + binding.config = gl.config; + binding.context = gl.context; + XrSessionCreateInfo session_info{XR_TYPE_SESSION_CREATE_INFO}; + session_info.next = &binding; + session_info.systemId = system; + if (!Check(xrCreateSession(instance, &session_info, &session), "xrCreateSession")) { + return false; + } + + XrReferenceSpaceCreateInfo space_info{XR_TYPE_REFERENCE_SPACE_CREATE_INFO}; + space_info.poseInReferenceSpace.orientation.w = 1.0f; + // LOCAL is the seated space: its origin is where the head was when the user last + // recentred, which is exactly the emulator's "host space". + space_info.referenceSpaceType = XR_REFERENCE_SPACE_TYPE_LOCAL; + if (!Check(xrCreateReferenceSpace(session, &space_info, &local_space), "create LOCAL")) { + return false; + } + space_info.referenceSpaceType = XR_REFERENCE_SPACE_TYPE_VIEW; + if (!Check(xrCreateReferenceSpace(session, &space_info, &view_space), "create VIEW")) { + return false; + } + + if (has_hand_tracking) { + CreateHandTrackers(); + } + if (has_metrics) { + FindMetrics(); + } + return true; + } + + /// The runtime's own counters (GPU load, the compositor's time, frames it had to repeat, + /// load per processor core...): whatever it offers goes into the log, since the app cannot + /// see any of that itself. + void FindMetrics() { + const auto enumerate = GetFunction<PFN_xrEnumeratePerformanceMetricsCounterPathsMETA>( + instance, "xrEnumeratePerformanceMetricsCounterPathsMETA"); + const auto set_state = GetFunction<PFN_xrSetPerformanceMetricsStateMETA>( + instance, "xrSetPerformanceMetricsStateMETA"); + query_metric = GetFunction<PFN_xrQueryPerformanceMetricsCounterMETA>( + instance, "xrQueryPerformanceMetricsCounterMETA"); + uint32_t count = 0; + if (enumerate == nullptr || set_state == nullptr || query_metric == nullptr || + XR_FAILED(enumerate(instance, 0, &count, nullptr)) || count == 0) { + return; + } + std::vector<XrPath> paths(count); + if (XR_FAILED(enumerate(instance, count, &count, paths.data()))) { + return; + } + XrPerformanceMetricsStateMETA state{XR_TYPE_PERFORMANCE_METRICS_STATE_META}; + state.enabled = XR_TRUE; + if (XR_FAILED(set_state(session, &state))) { + return; + } + for (uint32_t i = 0; i < count && i < paths.size(); ++i) { + char name[XR_MAX_PATH_LENGTH]{}; + uint32_t length = 0; + if (XR_FAILED(xrPathToString(instance, paths[i], sizeof(name), &length, name))) { + continue; + } + // "/perfmetrics_meta/device/gpu_utilization" -> "device/gpu_utilization" + std::string text{name}; + if (const size_t slash = text.find('/', 1); slash != std::string::npos) { + text.erase(0, slash + 1); + } + metrics.push_back({paths[i], text}); + } + LOGI("the runtime offers %zu performance counters", metrics.size()); + } + + /// One line with the present value of every counter the runtime has one for. + void ReportMetrics() { + if (metrics.empty()) { + return; + } + std::string line; + for (const Metric& metric : metrics) { + XrPerformanceMetricsCounterMETA counter{XR_TYPE_PERFORMANCE_METRICS_COUNTER_META}; + if (XR_FAILED(query_metric(session, metric.path, &counter))) { + continue; + } + char value[48]; + if ((counter.counterFlags & XR_PERFORMANCE_METRICS_COUNTER_FLOAT_VALUE_VALID_BIT_META) != + 0) { + std::snprintf(value, sizeof(value), "%.2f", counter.floatValue); + } else if ((counter.counterFlags & + XR_PERFORMANCE_METRICS_COUNTER_UINT_VALUE_VALID_BIT_META) != 0) { + std::snprintf(value, sizeof(value), "%u", counter.uintValue); + } else { + continue; + } + static constexpr const char* Units[] = {"", "%", " ms", " B", " Hz"}; + const auto unit = static_cast<size_t>(counter.counterUnit); + line += (line.empty() ? "" : ", ") + metric.name + " " + value + + (unit < std::size(Units) ? Units[unit] : ""); + } + if (!line.empty()) { + LOGI("runtime: %s", line.c_str()); + } + } + + void CreateHandTrackers() { + const auto create = + GetFunction<PFN_xrCreateHandTrackerEXT>(instance, "xrCreateHandTrackerEXT"); + locate_hand_joints = + GetFunction<PFN_xrLocateHandJointsEXT>(instance, "xrLocateHandJointsEXT"); + if (create == nullptr || locate_hand_joints == nullptr) { + has_hand_tracking = false; + return; + } + for (int hand = 0; hand < 2; ++hand) { + XrHandTrackerCreateInfoEXT info{XR_TYPE_HAND_TRACKER_CREATE_INFO_EXT}; + info.hand = hand == 0 ? XR_HAND_LEFT_EXT : XR_HAND_RIGHT_EXT; + info.handJointSet = XR_HAND_JOINT_SET_DEFAULT_EXT; + if (!Check(create(session, &info, &hand_trackers[hand]), "xrCreateHandTrackerEXT")) { + has_hand_tracking = false; + return; + } + } + LOGI("hand trackers created"); + } + + bool CreateSwapchain(Swapchain& swapchain, uint32_t width, uint32_t height) { + XrSwapchainCreateInfo info{XR_TYPE_SWAPCHAIN_CREATE_INFO}; + info.usageFlags = XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT | XR_SWAPCHAIN_USAGE_SAMPLED_BIT; + info.format = swapchain_format; + info.sampleCount = 1; + info.width = width; + info.height = height; + info.faceCount = 1; + info.arraySize = 1; + info.mipCount = 1; + if (!Check(xrCreateSwapchain(session, &info, &swapchain.handle), "xrCreateSwapchain")) { + return false; + } + swapchain.width = width; + swapchain.height = height; + + uint32_t count = 0; + xrEnumerateSwapchainImages(swapchain.handle, 0, &count, nullptr); + swapchain.images.assign(count, {XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR}); + if (!Check(xrEnumerateSwapchainImages( + swapchain.handle, count, &count, + reinterpret_cast<XrSwapchainImageBaseHeader*>(swapchain.images.data())), + "xrEnumerateSwapchainImages")) { + return false; + } + swapchain.framebuffers.assign(count, 0); + glGenFramebuffers(static_cast<GLsizei>(count), swapchain.framebuffers.data()); + for (uint32_t i = 0; i < count; ++i) { + glBindFramebuffer(GL_FRAMEBUFFER, swapchain.framebuffers[i]); + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, + swapchain.images[i].image, 0); + } + glBindFramebuffer(GL_FRAMEBUFFER, 0); + return true; + } + + bool InitRendering() { + uint32_t count = 0; + xrEnumerateSwapchainFormats(session, 0, &count, nullptr); + std::vector<int64_t> formats(count); + xrEnumerateSwapchainFormats(session, count, &count, formats.data()); + const bool srgb = std::find(formats.begin(), formats.end(), FormatSrgb8Alpha8) != + formats.end(); + swapchain_format = srgb ? FormatSrgb8Alpha8 : FormatRgba8; + decode_srgb = srgb; + + // Both eyes side by side in one image, like the frames arrive. + const uint32_t frame_width = options.eye_width * 2; + const uint32_t frame_height = options.eye_height; + const uint32_t swapchain_width = + max_swapchain_width != 0 ? std::min(frame_width, max_swapchain_width) : frame_width; + if (!CreateSwapchain(game_swapchain, swapchain_width, frame_height) || + !CreateSwapchain(status_swapchain, StatusImage::Width, StatusImage::Height)) { + return false; + } + LOGI("swapchains: %s, the game's %ux%u in %zu images, the panel's %ux%u in %zu; %u " + "formats on offer", + srgb ? "sRGB" : "plain RGBA", game_swapchain.width, game_swapchain.height, + game_swapchain.images.size(), status_swapchain.width, status_swapchain.height, + status_swapchain.images.size(), count); + for (const Swapchain* swapchain : {&game_swapchain, &status_swapchain}) { + for (const GLuint framebuffer : swapchain->framebuffers) { + glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); + const GLenum state = glCheckFramebufferStatus(GL_FRAMEBUFFER); + if (state != GL_FRAMEBUFFER_COMPLETE) { + LOGE("a swapchain image cannot be drawn to (0x%x)", state); + } + } + } + glBindFramebuffer(GL_FRAMEBUFFER, 0); + layer_width = shown_width = game_swapchain.width; + layer_height = shown_height = game_swapchain.height; + if (has_swapchain_state) { + UseCubicSampling(game_swapchain); + } + + if (!blitter.Create()) { + return false; + } + LOGI("frames are copied to the compositor's image %s", + !srgb || blitter.WritesUnencoded() ? "as they are" : "through a decoder"); + return frames.Create(gl.display, frame_width, frame_height, core); + } + + void PollEvents() { + XrEventDataBuffer event{XR_TYPE_EVENT_DATA_BUFFER}; + while (xrPollEvent(instance, &event) == XR_SUCCESS) { + if (event.type == XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED) { + const auto& changed = + *reinterpret_cast<const XrEventDataSessionStateChanged*>(&event); + LOGI("session state: %s", SessionStateName(changed.state)); + switch (changed.state) { + case XR_SESSION_STATE_READY: { + XrSessionBeginInfo begin{XR_TYPE_SESSION_BEGIN_INFO}; + begin.primaryViewConfigurationType = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO; + if (Check(xrBeginSession(session, &begin), "xrBeginSession")) { + session_running = true; + host_status.session_running = true; + ApplySessionSettings(); + // The game waited while nobody wore the headset. + core.SetPaused(false); + } + break; + } + case XR_SESSION_STATE_STOPPING: + xrEndSession(session); + session_running = false; + host_status.session_running = false; + // The headset came off: a game nobody sees should not play on. + core.SetPaused(true); + break; + case XR_SESSION_STATE_EXITING: + case XR_SESSION_STATE_LOSS_PENDING: + exit_requested = true; + break; + default: + break; + } + } else if (event.type == XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING) { + exit_requested = true; + } else if (event.type == XR_TYPE_EVENT_DATA_PERF_SETTINGS_EXT) { + // The system saying that the headset runs hot or cannot keep up: levels are + // 0 normal, 25 warning, 75 impaired. + const auto& changed = *reinterpret_cast<const XrEventDataPerfSettingsEXT*>(&event); + LOGW("performance notice: %s %s went from level %d to %d", + changed.domain == XR_PERF_SETTINGS_DOMAIN_CPU_EXT ? "processor" : "GPU", + changed.subDomain == XR_PERF_SETTINGS_SUB_DOMAIN_THERMAL_EXT + ? "temperature" + : changed.subDomain == XR_PERF_SETTINGS_SUB_DOMAIN_COMPOSITING_EXT + ? "compositing" + : "rendering", + static_cast<int>(changed.fromLevel), static_cast<int>(changed.toLevel)); + } else if (event.type == XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING) { + const auto& changed = + *reinterpret_cast<const XrEventDataReferenceSpaceChangePending*>(&event); + if (changed.referenceSpaceType == XR_REFERENCE_SPACE_TYPE_LOCAL) { + space_change_time = changed.changeTime; + } + } else if (event.type == XR_TYPE_EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB) { + const auto& changed = + *reinterpret_cast<const XrEventDataDisplayRefreshRateChangedFB*>(&event); + LOGI("display refresh rate %.0f -> %.0f Hz", changed.fromDisplayRefreshRate, + changed.toDisplayRefreshRate); + host_status.refresh_rate = changed.toDisplayRefreshRate; + } + event = {XR_TYPE_EVENT_DATA_BUFFER}; + } + } + + void ApplySessionSettings() { + if (has_refresh_rate) { + const auto enumerate = GetFunction<PFN_xrEnumerateDisplayRefreshRatesFB>( + instance, "xrEnumerateDisplayRefreshRatesFB"); + uint32_t count = 0; + if (enumerate != nullptr && XR_SUCCEEDED(enumerate(session, 0, &count, nullptr))) { + std::vector<float> rates(count); + enumerate(session, count, &count, rates.data()); + std::string list; + for (uint32_t i = 0; i < count && i < rates.size(); ++i) { + list += (list.empty() ? "" : ", ") + std::to_string(static_cast<int>(rates[i])); + } + LOGI("display refresh rates on offer: %s Hz", list.c_str()); + } + const auto request = GetFunction<PFN_xrRequestDisplayRefreshRateFB>( + instance, "xrRequestDisplayRefreshRateFB"); + if (request != nullptr && options.refresh_rate > 0.0f) { + Check(request(session, options.refresh_rate), "xrRequestDisplayRefreshRateFB"); + } else if (request != nullptr) { + // The emulated headset refreshes when this display does, and the game draws + // one frame for every two refreshes where it manages that and one for every + // three where it does not (the emulator holds it to whole numbers). At 90 Hz + // that is 45 frames a second in light scenes and 30 in the levels, with room + // for the scene at the size the console draws it at; at 72 Hz the levels sit + // just beyond what two refreshes allow, and get the smallest picture and + // frames of uneven length for it. + for (const float rate : {90.0f, 80.0f, 72.0f}) { + if (XR_SUCCEEDED(request(session, rate))) { + break; + } + } + } + const auto get = GetFunction<PFN_xrGetDisplayRefreshRateFB>( + instance, "xrGetDisplayRefreshRateFB"); + float rate = 0.0f; + if (get != nullptr && XR_SUCCEEDED(get(session, &rate))) { + LOGI("display refresh rate %.0f Hz", rate); + host_status.refresh_rate = rate; + } + } + if (has_performance) { + // An emulator needs every cycle it can get, on both processors. + const auto set_level = GetFunction<PFN_xrPerfSettingsSetPerformanceLevelEXT>( + instance, "xrPerfSettingsSetPerformanceLevelEXT"); + if (set_level != nullptr) { + const XrResult cpu = set_level(session, XR_PERF_SETTINGS_DOMAIN_CPU_EXT, + options.cpu_boost + ? XR_PERF_SETTINGS_LEVEL_BOOST_EXT + : XR_PERF_SETTINGS_LEVEL_SUSTAINED_HIGH_EXT); + const XrResult gpu = set_level(session, XR_PERF_SETTINGS_DOMAIN_GPU_EXT, + XR_PERF_SETTINGS_LEVEL_SUSTAINED_HIGH_EXT); + LOGI("performance levels asked for: processor %s -> %d, GPU sustained high -> %d " + "(0 is accepted)", + options.cpu_boost ? "boost" : "sustained high", static_cast<int>(cpu), + static_cast<int>(gpu)); + } + } + if (has_thread_settings) { + // This thread has to get its turn at every refresh. The emulator's threads cannot + // be named to the runtime: it only takes threads of the process that asks (those of + // a child are refused, see ProbeIdleSession), so their priorities are the + // emulator's own doing (SHADPS4_THREAD_NICE). + const auto set_thread = GetFunction<PFN_xrSetAndroidApplicationThreadKHR>( + instance, "xrSetAndroidApplicationThreadKHR"); + if (set_thread != nullptr) { + const XrResult result = + set_thread(session, XR_ANDROID_THREAD_TYPE_RENDERER_MAIN_KHR, + static_cast<uint32_t>(::gettid())); + LOGI("thread hint for the frame loop: %d", static_cast<int>(result)); + } + } + } + + /// What a session that has not begun answers to the settings the host makes when one does. + void ProbeIdleSession() { + ApplySessionSettings(); + const auto set_thread = GetFunction<PFN_xrSetAndroidApplicationThreadKHR>( + instance, "xrSetAndroidApplicationThreadKHR"); + if (has_thread_settings && set_thread != nullptr) { + // A thread of another process of the app, which is what the emulator's threads are. + // (On Horizon OS 207: XR_ERROR_ANDROID_THREAD_SETTINGS_ID_INVALID_KHR.) + const pid_t child = ::fork(); + if (child == 0) { + ::sleep(2); + ::_exit(0); + } + if (child > 0) { + const XrResult result = + set_thread(session, XR_ANDROID_THREAD_TYPE_APPLICATION_WORKER_KHR, + static_cast<uint32_t>(child)); + ::waitpid(child, nullptr, 0); + LOGI("thread hint for a thread of a child process: %d", static_cast<int>(result)); + } + } + ProbeBlit(); + ProbePanel(); + ProbeLayerSize(); + } + + /// Puts a picture on the status panel the way the app's text gets there, and looks at + /// what the panel's image holds afterwards: the upper half red, the lower half blue. + void ProbePanel() { + { + std::scoped_lock lock{status.mutex}; + status.pixels.resize(size_t{StatusImage::Width} * StatusImage::Height * 4); + for (int y = 0; y < StatusImage::Height; ++y) { + for (int x = 0; x < StatusImage::Width; ++x) { + uint8_t* pixel = status.pixels.data() + (size_t{StatusImage::Width} * y + x) * 4; + const bool upper = y < StatusImage::Height / 2; + pixel[0] = upper ? 200 : 30; + pixel[1] = 30; + pixel[2] = upper ? 30 : 200; + pixel[3] = 255; + } + } + ++status.version; + } + status_ready = false; + UpdateStatusPanel(); + if (!status_ready) { + LOGW("probe: the status panel's image could not be written"); + return; + } + // Every image of the swapchain that has the picture now has it the right way up? + int matching = 0; + for (const GLuint framebuffer : status_swapchain.framebuffers) { + uint8_t top[4]{}; + uint8_t bottom[4]{}; + glBindFramebuffer(GL_FRAMEBUFFER, framebuffer); + glReadPixels(StatusImage::Width / 2, StatusImage::Height * 3 / 4, 1, 1, GL_RGBA, + GL_UNSIGNED_BYTE, top); + glReadPixels(StatusImage::Width / 2, StatusImage::Height / 4, 1, 1, GL_RGBA, + GL_UNSIGNED_BYTE, bottom); + if (top[0] > 190 && top[2] < 40 && bottom[2] > 190 && bottom[0] < 40) { + ++matching; + } + } + const GLenum error = glGetError(); + glBindFramebuffer(GL_FRAMEBUFFER, 0); + LOGI("probe: status panel written; %d of %zu images hold it the right way up (GL error " + "0x%x)", + matching, status_swapchain.framebuffers.size(), error); + } + + /// What the system recommends for the game's layer while nothing is being shown. + void ProbeLayerSize() { + const auto convert = GetFunction<PFN_xrConvertTimespecTimeToTimeKHR>( + instance, "xrConvertTimespecTimeToTimeKHR"); + if (get_layer_resolution == nullptr || !has_time_conversion || convert == nullptr) { + LOGI("probe: no recommended layer size to ask for"); + return; + } + timespec now{}; + clock_gettime(CLOCK_MONOTONIC, &now); + XrTime time = 0; + if (XR_FAILED(convert(instance, &now, &time))) { + return; + } + // A frame as the emulator would deliver it: looking straight ahead, the game's view. + Protocol::Frame frame{}; + frame.orientation[3] = 1.0f; + frame.fov[0] = 1.207f; + frame.fov[1] = 1.181f; + frame.fov[2] = 1.263f; + frame.fov[3] = 1.263f; + XrCompositionLayerProjectionView views[2]{{XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW}, + {XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW}}; + XrCompositionLayerProjection projection{XR_TYPE_COMPOSITION_LAYER_PROJECTION}; + FillProjection(frame, game_swapchain.width, game_swapchain.height, views, projection); + XrRecommendedLayerResolutionGetInfoMETA info{ + XR_TYPE_RECOMMENDED_LAYER_RESOLUTION_GET_INFO_META}; + info.layer = reinterpret_cast<const XrCompositionLayerBaseHeader*>(&projection); + info.predictedDisplayTime = time + 20'000'000; + XrRecommendedLayerResolutionMETA recommended{XR_TYPE_RECOMMENDED_LAYER_RESOLUTION_META}; + const XrResult result = get_layer_resolution(session, &info, &recommended); + LOGI("probe: recommended layer size for %ux%u an eye: %dx%d, valid %d (result %d)", + game_swapchain.width / 2, game_swapchain.height, + recommended.recommendedImageDimensions.width, + recommended.recommendedImageDimensions.height, + static_cast<int>(recommended.isValid), static_cast<int>(result)); + } + + /// Copies a test picture into the image the compositor would show, the way frames are, and + /// reads it back: the top left of a frame has to end up top left and in its own colours, + /// at full size and at the smaller size the picture is shown at while the GPU is short. + void ProbeBlit() { + // Four fields, first row on top as in the emulator's frames: red, green / blue, yellow. + constexpr int Width = 64; + constexpr int Height = 32; + static constexpr uint8_t Fields[4][3] = { + {200, 30, 30}, {30, 200, 30}, {30, 30, 200}, {200, 200, 30}}; + std::vector<uint8_t> picture(Width * Height * 4); + for (int y = 0; y < Height; ++y) { + for (int x = 0; x < Width; ++x) { + const uint8_t* field = Fields[(y >= Height / 2 ? 2 : 0) + (x >= Width / 2 ? 1 : 0)]; + uint8_t* pixel = picture.data() + (y * Width + x) * 4; + pixel[0] = field[0]; + pixel[1] = field[1]; + pixel[2] = field[2]; + pixel[3] = 255; + } + } + GLuint texture = 0; + glGenTextures(1, &texture); + glBindTexture(GL_TEXTURE_2D, texture); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, Width, Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, + picture.data()); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + + for (const float scale : {1.0f, MinLayerScale}) { + const auto width = static_cast<uint32_t>(static_cast<float>(game_swapchain.width) * scale); + const auto height = + static_cast<uint32_t>(static_cast<float>(game_swapchain.height) * scale); + uint32_t index = 0; + XrSwapchainImageAcquireInfo acquire{XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO}; + const XrResult acquired = + xrAcquireSwapchainImage(game_swapchain.handle, &acquire, &index); + if (XR_FAILED(acquired)) { + LOGW("probe: no swapchain image to be had outside a session (%d)", + static_cast<int>(acquired)); + break; + } + XrSwapchainImageWaitInfo wait{XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO}; + wait.timeout = 1'000'000'000; + const XrResult waited = xrWaitSwapchainImage(game_swapchain.handle, &wait); + + glBindFramebuffer(GL_FRAMEBUFFER, game_swapchain.framebuffers[index]); + blitter.Draw(texture, width, height, false, decode_srgb); + // Top left and bottom right field, as GL counts rows: from the bottom. + uint8_t top_left[4]{}; + uint8_t bottom_right[4]{}; + glReadPixels(static_cast<GLint>(width / 4), static_cast<GLint>(height * 3 / 4), 1, 1, + GL_RGBA, GL_UNSIGNED_BYTE, top_left); + glReadPixels(static_cast<GLint>(width * 3 / 4), static_cast<GLint>(height / 4), 1, 1, + GL_RGBA, GL_UNSIGNED_BYTE, bottom_right); + const GLenum error = glGetError(); + glBindFramebuffer(GL_FRAMEBUFFER, 0); + XrSwapchainImageReleaseInfo release{XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO}; + const XrResult released = xrReleaseSwapchainImage(game_swapchain.handle, &release); + + const auto close = [](const uint8_t* seen, const uint8_t* expected) { + return std::abs(seen[0] - expected[0]) <= 3 && std::abs(seen[1] - expected[1]) <= 3 && + std::abs(seen[2] - expected[2]) <= 3; + }; + const bool right = close(top_left, Fields[0]) && close(bottom_right, Fields[3]); + LOGI("probe: picture copied to swapchain image %u at %ux%u: top left %u,%u,%u and " + "bottom right %u,%u,%u, %s (wait %d, release %d, GL error 0x%x)", + index, width, height, top_left[0], top_left[1], top_left[2], bottom_right[0], + bottom_right[1], bottom_right[2], right ? "as it should be" : "WRONG", + static_cast<int>(waited), static_cast<int>(released), error); + } + glBindTexture(GL_TEXTURE_2D, 0); + glDeleteTextures(1, &texture); + } + + /// Has the compositor read a swapchain's images with the GPU's cubic filter where it + /// enlarges them. The game's picture has less than half as many pixels across as the + /// display has for it; a linear filter turns that into a blur. + void UseCubicSampling(const Swapchain& swapchain) { + // From IMG_texture_filter_cubic. + static constexpr EGLenum CubicImg = 0x9139; + const auto get_state = + GetFunction<PFN_xrGetSwapchainStateFB>(instance, "xrGetSwapchainStateFB"); + const auto update = + GetFunction<PFN_xrUpdateSwapchainFB>(instance, "xrUpdateSwapchainFB"); + if (get_state == nullptr || update == nullptr) { + return; + } + XrSwapchainStateSamplerOpenGLESFB sampler{XR_TYPE_SWAPCHAIN_STATE_SAMPLER_OPENGL_ES_FB}; + const XrResult got = get_state( + swapchain.handle, reinterpret_cast<XrSwapchainStateBaseHeaderFB*>(&sampler)); + if (XR_FAILED(got)) { + LOGW("the compositor does not tell how it reads the game's picture (%d)", + static_cast<int>(got)); + return; + } + const EGLenum before = sampler.magFilter; + sampler.magFilter = CubicImg; + const XrResult updated = update( + swapchain.handle, reinterpret_cast<const XrSwapchainStateBaseHeaderFB*>(&sampler)); + LOGI("the compositor enlarges the game's picture with a cubic filter (was 0x%x): %s (%d)", + before, XR_SUCCEEDED(updated) ? "accepted" : "refused", static_cast<int>(updated)); + } + + /// Asks the system at what size it wants the game's picture: all of the image the frames + /// are copied to, or less of it while the GPU is short. That it is asked is what counts: + /// the system lets the GPU run faster for an app that gives way. The game gives way in the + /// size it draws its scene at, which is where the GPU's time goes; showing the finished + /// picture smaller saves nothing and blurs it, and is only done on request. + void UpdateLayerSize(XrTime display_time) { + if (get_layer_resolution == nullptr || !shown_frame) { + return; + } + // The question is about a layer: the one that would be shown at full size. + XrCompositionLayerProjectionView views[2]{{XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW}, + {XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW}}; + XrCompositionLayerProjection projection{XR_TYPE_COMPOSITION_LAYER_PROJECTION}; + FillProjection(*shown_frame, game_swapchain.width, game_swapchain.height, views, + projection); + XrRecommendedLayerResolutionGetInfoMETA info{ + XR_TYPE_RECOMMENDED_LAYER_RESOLUTION_GET_INFO_META}; + info.layer = reinterpret_cast<const XrCompositionLayerBaseHeader*>(&projection); + info.predictedDisplayTime = display_time; + XrRecommendedLayerResolutionMETA recommended{XR_TYPE_RECOMMENDED_LAYER_RESOLUTION_META}; + if (XR_FAILED(get_layer_resolution(session, &info, &recommended)) || + recommended.isValid != XR_TRUE) { + return; + } + recommended_width = recommended.recommendedImageDimensions.width; + recommended_height = recommended.recommendedImageDimensions.height; + // One eye's size. Never more than there is, and not so little that it shows. + const float full_width = static_cast<float>(game_swapchain.width / 2); + const float full_height = static_cast<float>(game_swapchain.height); + const float scale = std::clamp( + std::min(static_cast<float>(recommended.recommendedImageDimensions.width) / full_width, + static_cast<float>(recommended.recommendedImageDimensions.height) / + full_height), + options.follow_layer_size ? MinLayerScale : 1.0f, 1.0f); + // In steps, so that it does not change with every frame. + const uint32_t eye_width = + std::min(game_swapchain.width / 2, + (static_cast<uint32_t>(full_width * scale) + 15) / 16 * 16); + const uint32_t height = + std::min(game_swapchain.height, + (static_cast<uint32_t>(full_height * scale) + 15) / 16 * 16); + if (!layer_size_logged) { + layer_size_logged = true; + LOGI("the system recommends %dx%d for an eye; the game's picture is shown at %ux%u", + recommended.recommendedImageDimensions.width, + recommended.recommendedImageDimensions.height, eye_width, height); + } + layer_width = eye_width * 2; + layer_height = height; + } + + /// Copies the emulator's frame into the image the compositor shows. + bool BlitFrame(const Protocol::Frame& frame) { + if (!frames.IsValid(frame.buffer)) { + return false; + } + uint32_t index = 0; + XrSwapchainImageAcquireInfo acquire{XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO}; + if (XR_FAILED(xrAcquireSwapchainImage(game_swapchain.handle, &acquire, &index))) { + return false; + } + XrSwapchainImageWaitInfo wait{XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO}; + wait.timeout = XR_INFINITE_DURATION; + xrWaitSwapchainImage(game_swapchain.handle, &wait); + + // Into the lower left corner when the picture is to be smaller than the image. + glBindFramebuffer(GL_FRAMEBUFFER, game_swapchain.framebuffers[index]); + blitter.Draw(frames.Texture(frame.buffer), layer_width, layer_height, + frame.swap_red_blue != 0, decode_srgb); + glBindFramebuffer(GL_FRAMEBUFFER, 0); + shown_width = layer_width; + shown_height = layer_height; + + XrSwapchainImageReleaseInfo release{XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO}; + xrReleaseSwapchainImage(game_swapchain.handle, &release); + return true; + } + + void UpdateStatusPanel() { + std::vector<uint8_t> pixels; + { + std::scoped_lock lock{status.mutex}; + if (status.version == status_version || status.pixels.empty()) { + return; + } + pixels = status.pixels; + status_version = status.version; + } + uint32_t index = 0; + XrSwapchainImageAcquireInfo acquire{XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO}; + if (XR_FAILED(xrAcquireSwapchainImage(status_swapchain.handle, &acquire, &index))) { + return; + } + XrSwapchainImageWaitInfo wait{XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO}; + wait.timeout = XR_INFINITE_DURATION; + xrWaitSwapchainImage(status_swapchain.handle, &wait); + + // Bitmaps start at the top, GL textures at the bottom. + const size_t row_bytes = size_t{StatusImage::Width} * 4; + std::vector<uint8_t> flipped(pixels.size()); + for (int y = 0; y < StatusImage::Height; ++y) { + std::memcpy(flipped.data() + y * row_bytes, + pixels.data() + (StatusImage::Height - 1 - y) * row_bytes, row_bytes); + } + glBindTexture(GL_TEXTURE_2D, status_swapchain.images[index].image); + glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, StatusImage::Width, StatusImage::Height, GL_RGBA, + GL_UNSIGNED_BYTE, flipped.data()); + glBindTexture(GL_TEXTURE_2D, 0); + + XrSwapchainImageReleaseInfo release{XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO}; + xrReleaseSwapchainImage(status_swapchain.handle, &release); + status_ready = true; + } + + void Loop() { + while (!quit && !exit_requested) { + PollEvents(); + if (!session_running) { + if (options.probe && !probed) { + probed = true; + ProbeIdleSession(); + } + usleep(50'000); + continue; + } + + XrFrameState frame_state{XR_TYPE_FRAME_STATE}; + if (const XrResult waited = xrWaitFrame(session, nullptr, &frame_state); + XR_FAILED(waited)) { + NoteFrameFailure("xrWaitFrame", waited); + usleep(5'000); + continue; + } + // The runtime lets go of xrWaitFrame once for every refresh of the display, at + // the same point of each: the emulated headset takes its own refreshes from that. + if (host_status.refresh_rate > 0.0f) { + core.SendRefresh(host_status.refresh_rate); + } + if (const XrResult begun = xrBeginFrame(session, nullptr); XR_FAILED(begun)) { + NoteFrameFailure("xrBeginFrame", begun); + continue; + } + + const XrTime pose_time = + frame_state.predictedDisplayTime + + static_cast<XrTime>(std::clamp(options.predict_ms, 0.0f, 80.0f) * 1e6f); + SendHeadPose(pose_time); + SendPadPose(pose_time); + UpdateLayerSize(frame_state.predictedDisplayTime); + + const auto now = std::chrono::steady_clock::now(); + if (const auto frame = core.TakeFrame()) { + if (BlitFrame(*frame)) { + shown_frame = *frame; + last_frame_time = now; + ++frame_count; + } + } + ReportPacing(now); + UpdateStatusPanel(); + + // The panel covers boot, loading screens that last, and a core that died. + const bool stale = !shown_frame || + now - last_frame_time > std::chrono::milliseconds{2500}; + + XrCompositionLayerProjectionView views[2]{{XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW}, + {XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW}}; + XrCompositionLayerProjection projection{XR_TYPE_COMPOSITION_LAYER_PROJECTION}; + XrCompositionLayerSettingsFB layer_settings{XR_TYPE_COMPOSITION_LAYER_SETTINGS_FB}; + XrCompositionLayerQuad quad{XR_TYPE_COMPOSITION_LAYER_QUAD}; + std::vector<const XrCompositionLayerBaseHeader*> layers; + + if (frame_state.shouldRender == XR_TRUE) { + if (shown_frame) { + FillProjection(*shown_frame, shown_width, shown_height, views, projection); + if (has_layer_settings) { + // The game draws fewer pixels per degree than the display has. + layer_settings.layerFlags = + options.sharpen == 4 + ? XR_COMPOSITION_LAYER_SETTINGS_NORMAL_SHARPENING_BIT_FB + : XR_COMPOSITION_LAYER_SETTINGS_QUALITY_SHARPENING_BIT_FB; + if (has_auto_filter) { + layer_settings.layerFlags |= + XR_COMPOSITION_LAYER_SETTINGS_AUTO_LAYER_FILTER_BIT_META; + } + projection.next = &layer_settings; + } + layers.push_back( + reinterpret_cast<const XrCompositionLayerBaseHeader*>(&projection)); + } + if ((stale || options.show_stats) && status_ready) { + quad.layerFlags = XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT; + quad.space = view_space; + quad.eyeVisibility = XR_EYE_VISIBILITY_BOTH; + quad.subImage.swapchain = status_swapchain.handle; + quad.subImage.imageRect.extent = {StatusImage::Width, StatusImage::Height}; + quad.pose.orientation.w = 1.0f; + if (stale) { + quad.pose.position = {0.0f, 0.0f, -1.6f}; + quad.size = {1.4f, 0.7f}; + } else { + // Over the game: out of the way of what is being played. + quad.pose.position = {0.0f, -0.55f, -1.6f}; + quad.size = {0.56f, 0.28f}; + } + layers.push_back(reinterpret_cast<const XrCompositionLayerBaseHeader*>(&quad)); + } + } + + XrFrameEndInfo end{XR_TYPE_FRAME_END_INFO}; + end.displayTime = frame_state.predictedDisplayTime; + end.environmentBlendMode = XR_ENVIRONMENT_BLEND_MODE_OPAQUE; + end.layerCount = static_cast<uint32_t>(layers.size()); + end.layers = layers.data(); + if (const XrResult ended = xrEndFrame(session, &end); XR_FAILED(ended)) { + // A layer the runtime does not accept is a frame nobody sees. + NoteFrameFailure("xrEndFrame", ended); + } else if (!layers.empty() && !shown_logged) { + shown_logged = true; + LOGI("first frame handed to the compositor: %zu layer(s), %s", layers.size(), + shown_frame ? "the game's picture" : "the status panel"); + } else if (shown_frame && !game_shown_logged && !layers.empty()) { + game_shown_logged = true; + LOGI("the game's first picture handed to the compositor: %ux%u an eye, field of " + "view %.1f/%.1f/%.1f/%.1f degrees (out, in, up, down)", + shown_width / 2, shown_height, + std::atan(shown_frame->fov[0]) * 57.29578f, + std::atan(shown_frame->fov[1]) * 57.29578f, + std::atan(shown_frame->fov[2]) * 57.29578f, + std::atan(shown_frame->fov[3]) * 57.29578f); + } + } + } + + /// Frame calls that fail are frames nobody sees, and nothing else would tell: the first + /// few go to the log, then every thousandth. + void NoteFrameFailure(const char* what, XrResult result) { + ++frame_failures; + if (frame_failures <= 5 || frame_failures % 1000 == 0) { + LOGE("%s failed: %d (%u frame calls failed so far)", what, static_cast<int>(result), + frame_failures); + } + } + + /// Every ten seconds: how many frames the game delivered against how many the headset + /// showed (the first number over the second is how much of the motion is the game's own), + /// what the emulator used to get there, and what was seen of the hands and the controller + /// they hold. + void ReportPacing(std::chrono::steady_clock::time_point now) { + ++display_frames; + if (now - last_report < std::chrono::seconds{10}) { + return; + } + const float seconds = std::chrono::duration<float>(now - last_report).count(); + const CoreProcess::Usage usage = core.GetUsage(); + LOGI("pacing: game %.1f fps, display %.1f Hz; emulator %.0f%% of a processor on %s, " + "%d MB; head tracked %.0f%%; picture shown at %ux%u an eye (the system recommends " + "%dx%d)", + static_cast<float>(frame_count - reported_frames) / seconds, + static_cast<float>(display_frames) / seconds, + (usage.cpu_seconds - reported_cpu_seconds) * 100.0 / seconds, + usage.cpus.empty() ? "?" : usage.cpus.c_str(), usage.memory_mb, + 100.0f * static_cast<float>(head_tracked_frames) / static_cast<float>(display_frames), + shown_width / 2, shown_height, recommended_width, recommended_height); + if (head_tracked_frames != 0) { + // Where the head is in the headset's own space, which the emulator counts from the + // player's seat: a view that is off shows here as a head that has moved away from + // where it was when the view was last reset. + const XrVector3f forward = Rotate(head_pose.orientation, {0.0f, 0.0f, -1.0f}); + LOGI("head: at %.2f %.2f %.2f of the headset's space (right, up, back), within " + "%.2f %.2f %.2f of it these ten seconds; facing %.0f degrees to the left of its " + "straight ahead, %.0f up", + head_pose.position.x, head_pose.position.y, head_pose.position.z, + head_high.x - head_low.x, head_high.y - head_low.y, head_high.z - head_low.z, + std::atan2(-forward.x, -forward.z) * 57.29578f, + std::asin(std::clamp(forward.y, -1.0f, 1.0f)) * 57.29578f); + } + if (has_hand_tracking) { + // Where the controller was taken to be, seen from the head: to the right, up and + // forward of it. The game's first screen wants it around 0, -0.17, 0.50. + const float palms = palm_samples != 0 ? palm_distance / palm_samples : 0.0f; + const float held = pad_samples != 0 ? 1.0f / static_cast<float>(pad_samples) : 0.0f; + LOGI("hands: both seen %.0f%% of the time, %.2f m apart; holding the controller " + "%.0f%%, on average %.2f right, %.2f up, %.2f ahead of the head", + 100.0f * static_cast<float>(palm_samples) / static_cast<float>(display_frames), + palms, + 100.0f * static_cast<float>(pad_samples) / static_cast<float>(display_frames), + pad_from_head.x * held, pad_from_head.y * held, -pad_from_head.z * held); + } + ReportMetrics(); + reported_frames = frame_count; + reported_cpu_seconds = usage.cpu_seconds; + display_frames = 0; + head_tracked_frames = 0; + palm_samples = 0; + palm_distance = 0.0f; + pad_samples = 0; + pad_from_head = {}; + last_report = now; + } + + void SendHeadPose(XrTime display_time) { + XrSpaceVelocity velocity{XR_TYPE_SPACE_VELOCITY}; + XrSpaceLocation location{XR_TYPE_SPACE_LOCATION}; + location.next = &velocity; + if (XR_SUCCEEDED(xrLocateSpace(view_space, local_space, display_time, &location)) && + (location.locationFlags & XR_SPACE_LOCATION_ORIENTATION_VALID_BIT) != 0 && + (location.locationFlags & XR_SPACE_LOCATION_POSITION_VALID_BIT) != 0) { + Protocol::Pose pose; + pose.position[0] = location.pose.position.x; + pose.position[1] = location.pose.position.y; + pose.position[2] = location.pose.position.z; + pose.orientation[0] = location.pose.orientation.x; + pose.orientation[1] = location.pose.orientation.y; + pose.orientation[2] = location.pose.orientation.z; + pose.orientation[3] = location.pose.orientation.w; + if ((velocity.velocityFlags & XR_SPACE_VELOCITY_LINEAR_VALID_BIT) != 0) { + pose.linear_velocity[0] = velocity.linearVelocity.x; + pose.linear_velocity[1] = velocity.linearVelocity.y; + pose.linear_velocity[2] = velocity.linearVelocity.z; + } + if ((velocity.velocityFlags & XR_SPACE_VELOCITY_ANGULAR_VALID_BIT) != 0) { + pose.angular_velocity[0] = velocity.angularVelocity.x; + pose.angular_velocity[1] = velocity.angularVelocity.y; + pose.angular_velocity[2] = velocity.angularVelocity.z; + } + core.SendPose(pose); + head_pose = location.pose; + if (head_tracked_frames == 0) { + head_low = head_high = location.pose.position; + } + head_low = {std::min(head_low.x, location.pose.position.x), + std::min(head_low.y, location.pose.position.y), + std::min(head_low.z, location.pose.position.z)}; + head_high = {std::max(head_high.x, location.pose.position.x), + std::max(head_high.y, location.pose.position.y), + std::max(head_high.z, location.pose.position.z)}; + ++head_tracked_frames; + } + + // The distance between the eyes follows the headset's lens adjustment. + XrViewLocateInfo locate{XR_TYPE_VIEW_LOCATE_INFO}; + locate.viewConfigurationType = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO; + locate.displayTime = display_time; + locate.space = view_space; + XrViewState view_state{XR_TYPE_VIEW_STATE}; + XrView eye_views[2]{{XR_TYPE_VIEW}, {XR_TYPE_VIEW}}; + uint32_t view_count = 0; + if (XR_SUCCEEDED(xrLocateViews(session, &locate, &view_state, 2, &view_count, eye_views)) && + view_count == 2 && + (view_state.viewStateFlags & XR_VIEW_STATE_POSITION_VALID_BIT) != 0) { + const float dx = eye_views[1].pose.position.x - eye_views[0].pose.position.x; + const float dy = eye_views[1].pose.position.y - eye_views[0].pose.position.y; + const float dz = eye_views[1].pose.position.z - eye_views[0].pose.position.z; + const float measured = std::sqrt(dx * dx + dy * dy + dz * dz); + if (std::abs(measured - ipd) > 0.0002f || ++frames_since_optics > 300) { + ipd = measured; + frames_since_optics = 0; + core.SendOptics(ipd); + } + } + } + + /// Where the palm of a hand is, if the headset sees it. + std::optional<XrVector3f> LocatePalm(int hand, XrTime time) { + XrHandJointLocationEXT joints[XR_HAND_JOINT_COUNT_EXT]; + XrHandJointLocationsEXT locations{XR_TYPE_HAND_JOINT_LOCATIONS_EXT}; + locations.jointCount = XR_HAND_JOINT_COUNT_EXT; + locations.jointLocations = joints; + XrHandJointsLocateInfoEXT info{XR_TYPE_HAND_JOINTS_LOCATE_INFO_EXT}; + info.baseSpace = local_space; + info.time = time; + if (XR_FAILED(locate_hand_joints(hand_trackers[hand], &info, &locations)) || + locations.isActive != XR_TRUE) { + return std::nullopt; + } + const auto& palm = joints[XR_HAND_JOINT_PALM_EXT]; + if ((palm.locationFlags & XR_SPACE_LOCATION_POSITION_VALID_BIT) == 0) { + return std::nullopt; + } + return palm.pose.position; + } + + /// A gamepad cannot be tracked, the hands that hold it can: both palms a controller's width + /// apart give away where it is and which way it points. + void SendPadPose(XrTime display_time) { + Protocol::PadPose message; + const uint32_t requests = recenter_requests.exchange(0); + if ((requests & XrRecenter::Pad) != 0) { + message.flags |= Protocol::PadPose::RecenterYaw; + } + // The headset's own "reset view" moves the space the poses are given in: from the + // moment it says, the head is where it rests, and the emulator has to hear of it. + const bool system_reset = space_change_time != 0 && display_time >= space_change_time; + if (system_reset) { + space_change_time = 0; + } + if ((requests & XrRecenter::Seat) != 0 || system_reset) { + message.flags |= Protocol::PadPose::RecenterSeat; + LOGI("view reset: %s", system_reset ? "the headset's own" : "asked for by the player"); + } + + bool seen = false; + if (has_hand_tracking) { + const auto left = LocatePalm(0, display_time); + const auto right = LocatePalm(1, display_time); + if (left && right) { + const XrVector3f across{right->x - left->x, right->y - left->y, + right->z - left->z}; + const float distance = + std::sqrt(across.x * across.x + across.y * across.y + across.z * across.z); + ++palm_samples; + palm_distance += distance; + // Hands further apart, or closer together, are not holding a controller. + if (distance > 0.05f && distance < 0.32f) { + XrVector3f centre{(left->x + right->x) * 0.5f, (left->y + right->y) * 0.5f, + (left->z + right->z) * 0.5f}; + const float level = std::sqrt(across.x * across.x + across.z * across.z); + if (level > 0.6f * distance) { + // The line from the left to the right palm is the controller's + // sideways axis; its heading follows from that. + const float yaw = std::atan2(-across.z, across.x); + message.yaw = yaw; + message.flags |= Protocol::PadPose::YawValid; + // The palms close around the grips, which sit behind and below the + // middle of the controller. + centre.x += -std::sin(yaw) * 0.035f; + centre.z += -std::cos(yaw) * 0.035f; + } + centre.y += 0.015f; + + if (pad_seen && display_time > pad_time) { + const float elapsed = + static_cast<float>(display_time - pad_time) * 1e-9f; + if (elapsed < 0.1f) { + const float blend = 0.4f; + pad_velocity.x += + ((centre.x - pad_position.x) / elapsed - pad_velocity.x) * blend; + pad_velocity.y += + ((centre.y - pad_position.y) / elapsed - pad_velocity.y) * blend; + pad_velocity.z += + ((centre.z - pad_position.z) / elapsed - pad_velocity.z) * blend; + } + } else { + pad_velocity = {}; + } + pad_position = centre; + pad_time = display_time; + + // For the log: the same, as seen from the head. + const XrQuaternionf to_head{-head_pose.orientation.x, -head_pose.orientation.y, + -head_pose.orientation.z, head_pose.orientation.w}; + const XrVector3f offset = + Rotate(to_head, {centre.x - head_pose.position.x, + centre.y - head_pose.position.y, + centre.z - head_pose.position.z}); + pad_from_head.x += offset.x; + pad_from_head.y += offset.y; + pad_from_head.z += offset.z; + ++pad_samples; + + message.flags |= Protocol::PadPose::PositionValid; + message.position[0] = centre.x; + message.position[1] = centre.y; + message.position[2] = centre.z; + message.linear_velocity[0] = pad_velocity.x; + message.linear_velocity[1] = pad_velocity.y; + message.linear_velocity[2] = pad_velocity.z; + seen = true; + } + } + } + + // While the hands are seen, every frame; once more when they are lost, so that the + // emulator stops trusting the last position. + if (seen || pad_seen || message.flags != 0) { + core.SendPadPose(message); + } + pad_seen = seen; + host_status.hands_tracked = seen; + } + + /// Describes the shown frame to the compositor: where the head was when the emulator drew + /// it and with what field of view, so that it can be corrected for how the head has moved. + /// `width` by `height` is the part of the image the frame (both eyes) was copied to. + void FillProjection(const Protocol::Frame& frame, uint32_t width, uint32_t height, + XrCompositionLayerProjectionView* views, + XrCompositionLayerProjection& projection) const { + // The runtime refuses a layer whose orientation is not a rotation, and with it the + // whole frame: whatever arrives is brought to length one, and nothing usable becomes + // "straight ahead". + XrQuaternionf orientation{frame.orientation[0], frame.orientation[1], + frame.orientation[2], frame.orientation[3]}; + const float length = + std::sqrt(orientation.x * orientation.x + orientation.y * orientation.y + + orientation.z * orientation.z + orientation.w * orientation.w); + if (std::isfinite(length) && length > 0.5f) { + orientation = {orientation.x / length, orientation.y / length, orientation.z / length, + orientation.w / length}; + } else { + orientation = {0.0f, 0.0f, 0.0f, 1.0f}; + } + const float angle_out = std::atan(frame.fov[0]); + const float angle_in = std::atan(frame.fov[1]); + const float angle_up = std::atan(frame.fov[2]); + const float angle_down = std::atan(frame.fov[3]); + const int32_t eye_width = static_cast<int32_t>(width / 2); + + for (int eye = 0; eye < 2; ++eye) { + const float side = eye == 0 ? -0.5f : 0.5f; + const XrVector3f offset = Rotate(orientation, {side * ipd, 0.0f, 0.0f}); + views[eye].pose.orientation = orientation; + views[eye].pose.position = {frame.position[0] + offset.x, + frame.position[1] + offset.y, + frame.position[2] + offset.z}; + // "Out" is towards the temple: left for the left eye, right for the right one. + views[eye].fov.angleLeft = eye == 0 ? -angle_out : -angle_in; + views[eye].fov.angleRight = eye == 0 ? angle_in : angle_out; + views[eye].fov.angleUp = angle_up; + views[eye].fov.angleDown = -angle_down; + views[eye].subImage.swapchain = game_swapchain.handle; + views[eye].subImage.imageRect.offset = {eye * eye_width, 0}; + views[eye].subImage.imageRect.extent = {eye_width, static_cast<int32_t>(height)}; + } + projection.space = local_space; + projection.viewCount = 2; + projection.views = views; + } + + void Shutdown() { + frames.Destroy(gl.display); + blitter.Destroy(); + if (instance != XR_NULL_HANDLE) { + const auto destroy_hand_tracker = + GetFunction<PFN_xrDestroyHandTrackerEXT>(instance, "xrDestroyHandTrackerEXT"); + for (XrHandTrackerEXT tracker : hand_trackers) { + if (tracker != XR_NULL_HANDLE && destroy_hand_tracker != nullptr) { + destroy_hand_tracker(tracker); + } + } + } + for (Swapchain* swapchain : {&game_swapchain, &status_swapchain}) { + if (swapchain->handle != XR_NULL_HANDLE) { + xrDestroySwapchain(swapchain->handle); + } + } + if (local_space != XR_NULL_HANDLE) { + xrDestroySpace(local_space); + } + if (view_space != XR_NULL_HANDLE) { + xrDestroySpace(view_space); + } + if (session != XR_NULL_HANDLE) { + xrDestroySession(session); + } + if (instance != XR_NULL_HANDLE) { + xrDestroyInstance(instance); + } + gl.Destroy(); + } + + JavaVM* vm; + jobject activity; + CoreProcess& core; + StatusImage& status; + XrHostOptions options; + XrHostStatus& host_status; + std::atomic<bool>& quit; + std::atomic<uint32_t>& recenter_requests; + + GlContext gl; + + XrInstance instance{XR_NULL_HANDLE}; + XrSystemId system{XR_NULL_SYSTEM_ID}; + XrSession session{XR_NULL_HANDLE}; + XrSpace local_space{XR_NULL_HANDLE}; + XrSpace view_space{XR_NULL_HANDLE}; + bool has_refresh_rate{}; + bool has_swapchain_state{}; + int32_t recommended_width{}; + int32_t recommended_height{}; + bool has_performance{}; + bool has_thread_settings{}; + bool has_layer_settings{}; + bool has_auto_filter{}; + bool has_hand_tracking{}; + bool has_layer_resolution{}; + bool has_metrics{}; + bool has_time_conversion{}; + bool session_running{}; + bool exit_requested{}; + bool probed{}; + uint32_t frame_failures{}; + bool shown_logged{}; + bool game_shown_logged{}; + uint32_t max_swapchain_width{}; + + XrHandTrackerEXT hand_trackers[2]{XR_NULL_HANDLE, XR_NULL_HANDLE}; + PFN_xrLocateHandJointsEXT locate_hand_joints{}; + /// When the headset's system redefines the space poses are given in (its "reset view"), + /// or 0. + XrTime space_change_time{}; + bool pad_seen{}; + XrVector3f pad_position{}; + XrVector3f pad_velocity{}; + XrTime pad_time{}; + + struct Metric { + XrPath path; + std::string name; + }; + std::vector<Metric> metrics; + PFN_xrQueryPerformanceMetricsCounterMETA query_metric{}; + + + /// The least of the image the game's picture is shown at, whatever the system recommends. + static constexpr float MinLayerScale = 0.85f; + PFN_xrGetRecommendedLayerResolutionMETA get_layer_resolution{}; + bool layer_size_logged{}; + /// The part of the game's image the next frame is copied to, and the part the frame that + /// is being shown was copied to: both eyes, side by side from the lower left corner. + uint32_t layer_width{}; + uint32_t layer_height{}; + uint32_t shown_width{}; + uint32_t shown_height{}; + + int64_t swapchain_format{FormatRgba8}; + bool decode_srgb{}; + Swapchain game_swapchain; + Swapchain status_swapchain; + FrameBlitter blitter; + FrameBuffers frames; + + std::optional<Protocol::Frame> shown_frame; + std::chrono::steady_clock::time_point last_frame_time{}; + std::chrono::steady_clock::time_point last_report{std::chrono::steady_clock::now()}; + uint32_t frame_count{}; + uint32_t reported_frames{}; + uint32_t display_frames{}; + double reported_cpu_seconds{}; + // What the log says of the last ten seconds. + XrPosef head_pose{{0.0f, 0.0f, 0.0f, 1.0f}, {}}; + // The corners of the box the head stayed in since the last report. + XrVector3f head_low{}; + XrVector3f head_high{}; + uint32_t head_tracked_frames{}; + uint32_t palm_samples{}; + float palm_distance{}; + uint32_t pad_samples{}; + XrVector3f pad_from_head{}; + uint64_t status_version{}; + bool status_ready{}; + float ipd{0.063f}; + uint32_t frames_since_optics{}; +}; + +} // namespace + +void RunXrHost(JavaVM* vm, jobject activity, CoreProcess& core, StatusImage& status, + const XrHostOptions& options, XrHostStatus& host_status, std::atomic<bool>& quit, + std::atomic<uint32_t>& recenter_requests) { + Host host{vm, activity, core, status, options, host_status, quit, recenter_requests}; + host.Run(); +} diff --git a/quest-host/cpp/xr_host.h b/quest-host/cpp/xr_host.h new file mode 100644 index 0000000..7aed149 --- /dev/null +++ b/quest-host/cpp/xr_host.h @@ -0,0 +1,88 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +#pragma once + +#include <atomic> +#include <cstdint> +#include <mutex> +#include <vector> + +#include <jni.h> + +class CoreProcess; + +/// A picture the Java side draws (text is far easier there) and the headset shows on a floating +/// panel whenever the game itself has nothing on screen. +struct StatusImage { + static constexpr int Width = 1024; + static constexpr int Height = 512; + + std::mutex mutex; + std::vector<uint8_t> pixels; ///< RGBA, top row first + uint64_t version{}; +}; + +struct XrHostOptions { + /// Display refresh rate to ask for, 0 keeps the system default. + float refresh_rate{0.0f}; + /// Size of one eye in the buffers frames are delivered in. + uint32_t eye_width{1440}; + uint32_t eye_height{1536}; + /// Use the wearer's hands, as the headset sees them around the gamepad, to place the + /// controller in the game. + bool track_hands{true}; + /// What the compositor does to the game's picture, which is coarser than the display, on + /// top of showing it: 0 and 1 nothing (with 1 the emulator sharpens the picture itself, + /// which is not this struct's business), 2 its Super Resolution filter on every refresh, + /// 3 the same but only while the system finds the GPU has the time for it, 4 its plainer + /// and cheaper sharpening filter. + int sharpen{1}; + /// Have the compositor read the game's picture with a cubic filter instead of a linear + /// one where it enlarges it: sharper, for a little of the GPU's time on every refresh. + bool cubic{}; + /// Keep the status panel in view (small, below the middle) while the game runs, for the + /// figures the app writes on it. + bool show_stats{}; + /// Ask the system from moment to moment for the size it recommends for the picture. It + /// counts an app that asks among those that give way when the GPU is short, which is its + /// condition for the higher GPU clock levels. This app gives way where the GPU's time + /// goes: in the size the game draws its scene at, which the emulator sees to. + bool dynamic_resolution{true}; + /// Also show the picture at the recommended size instead of at full size. That saves next + /// to nothing (the picture is copied once per frame of the game) and blurs what the game + /// drew; it is what the app did up to version 0.6. + bool follow_layer_size{}; + /// Ask for the processor's "boost" level: its fastest clock for the first 45 seconds and + /// for up to a fifth of the time after that, as the system sees fit. That is when the + /// emulator translates most of the game's code. + bool cpu_boost{true}; + /// For the probe that runs the host without anybody wearing the headset: ask the session + /// that never begins for everything that is otherwise asked when it does (refresh rate, + /// performance levels, thread hints), to have the answers in the log. + bool probe{}; + /// How far beyond the next display refresh the head pose given to the game is predicted, + /// in milliseconds. A frame is on the display some tens of milliseconds after the game + /// read the pose it drew it for; aiming at that moment leaves the compositor less to + /// correct, which is what shows as black edges when the head turns. + float predict_ms{25.0f}; +}; + +/// What a request to reset the view asks for (bits of the counter RunXrHost is given). +namespace XrRecenter { +/// The way the controller points right now is straight ahead. +inline constexpr uint32_t Pad = 1; +/// Where the head is now is where the player sits, and the way it faces is straight ahead. +inline constexpr uint32_t Seat = 2; +} // namespace XrRecenter + +/// What the host worked out about the session, for the status panel and for logging. +struct XrHostStatus { + std::atomic<bool> session_running{}; + std::atomic<bool> hands_tracked{}; + std::atomic<float> refresh_rate{}; +}; + +/// Owns the OpenXR session: feeds the head pose to the core and shows the stereo frames it +/// delivers. Blocks until `quit` is set or the system ends the session. +void RunXrHost(JavaVM* vm, jobject activity, CoreProcess& core, StatusImage& status, + const XrHostOptions& options, XrHostStatus& host_status, std::atomic<bool>& quit, + std::atomic<uint32_t>& recenter_requests); diff --git a/quest-host/cpp/xr_probe.cpp b/quest-host/cpp/xr_probe.cpp new file mode 100644 index 0000000..0c5c209 --- /dev/null +++ b/quest-host/cpp/xr_probe.cpp @@ -0,0 +1,221 @@ +// SPDX-License-Identifier: GPL-2.0-or-later + +// What can be learnt about the headset's OpenXR runtime without a session, and so without +// anybody wearing the headset: that the app finds the runtime at all, which of the extensions +// the host relies on it has and, if it lets an instance be made for something that is not an +// activity, what it says about the system and what its performance counters are called. +// The last step runs the host itself for a few seconds: everything it sets up before a session +// begins (session, spaces, swapchains, hand trackers), which is as far as it gets with nobody +// wearing the headset. +// Runs from the SandboxShell instrumentation like the self test. + +#include <algorithm> +#include <atomic> +#include <chrono> +#include <cstdio> +#include <cstring> +#include <string> +#include <thread> +#include <vector> + +#include <jni.h> + +#include "core_process.h" +#include "gl_frames.h" +#include "xr_host.h" + +#define XR_USE_PLATFORM_ANDROID +#define XR_USE_GRAPHICS_API_OPENGL_ES +#include <openxr/openxr.h> +#include <openxr/openxr_platform.h> + +#include "log.h" + +namespace { + +/// The extensions the host enables when they are there, and the two it cannot do without. +constexpr const char* Wanted[] = { + XR_KHR_ANDROID_CREATE_INSTANCE_EXTENSION_NAME, + XR_KHR_OPENGL_ES_ENABLE_EXTENSION_NAME, + XR_FB_DISPLAY_REFRESH_RATE_EXTENSION_NAME, + XR_EXT_PERFORMANCE_SETTINGS_EXTENSION_NAME, + XR_KHR_ANDROID_THREAD_SETTINGS_EXTENSION_NAME, + XR_FB_COMPOSITION_LAYER_SETTINGS_EXTENSION_NAME, + XR_META_AUTOMATIC_LAYER_FILTER_EXTENSION_NAME, + XR_EXT_HAND_TRACKING_EXTENSION_NAME, + XR_META_RECOMMENDED_LAYER_RESOLUTION_EXTENSION_NAME, + XR_META_PERFORMANCE_METRICS_EXTENSION_NAME, +}; + +template <typename Function> +Function GetFunction(XrInstance instance, const char* name) { + PFN_xrVoidFunction function = nullptr; + xrGetInstanceProcAddr(instance, name, &function); + return reinterpret_cast<Function>(function); +} + +} // namespace + +extern "C" JNIEXPORT jstring JNICALL Java_com_astrobotquest_vrhost_SandboxShell_nativeXrProbe( + JNIEnv* env, jclass, jobject context, jstring log_file, jint level) { + const char* log_path = env->GetStringUTFChars(log_file, nullptr); + SetLogFile(log_path); + env->ReleaseStringUTFChars(log_file, log_path); + + std::string report; + const auto note = [&](const char* format, auto... values) { + char line[1024]; + std::snprintf(line, sizeof(line), format, values...); + LOGI("xr probe: %s", line); + report += line; + report += '\n'; + }; + + JavaVM* vm = nullptr; + env->GetJavaVM(&vm); + if (level >= 3) { + // The host as the app runs it, with no emulator behind it and nobody to show a session + // to: it sets itself up, waits for a session that does not come, and is told to stop. + CoreProcess core; + StatusImage status; + XrHostOptions options; + options.probe = true; + XrHostStatus host_status; + std::atomic<bool> quit{false}; + std::atomic<uint32_t> recenter_requests{0}; + std::thread stopper{[&quit] { + std::this_thread::sleep_for(std::chrono::seconds{5}); + quit = true; + }}; + RunXrHost(vm, context, core, status, options, host_status, quit, recenter_requests); + stopper.join(); + note("the host ran and stopped: session %s, refresh rate %.0f Hz", + host_status.session_running ? "running" : "not running", + host_status.refresh_rate.load()); + return env->NewStringUTF(report.c_str()); + } + const auto initialize_loader = + GetFunction<PFN_xrInitializeLoaderKHR>(XR_NULL_HANDLE, "xrInitializeLoaderKHR"); + if (initialize_loader == nullptr) { + note("%s", "the loader has no xrInitializeLoaderKHR"); + return env->NewStringUTF(report.c_str()); + } + XrLoaderInitInfoAndroidKHR loader_info{XR_TYPE_LOADER_INIT_INFO_ANDROID_KHR}; + loader_info.applicationVM = vm; + loader_info.applicationContext = context; + const XrResult loader_result = initialize_loader( + reinterpret_cast<const XrLoaderInitInfoBaseHeaderKHR*>(&loader_info)); + note("loader initialised: %d", static_cast<int>(loader_result)); + if (XR_FAILED(loader_result)) { + return env->NewStringUTF(report.c_str()); + } + + uint32_t count = 0; + const XrResult enumerate_result = + xrEnumerateInstanceExtensionProperties(nullptr, 0, &count, nullptr); + std::vector<XrExtensionProperties> available(count, {XR_TYPE_EXTENSION_PROPERTIES}); + if (count != 0) { + xrEnumerateInstanceExtensionProperties(nullptr, count, &count, available.data()); + } + note("the runtime lists %u extensions (%d)", count, static_cast<int>(enumerate_result)); + std::vector<const char*> enabled; + for (const char* name : Wanted) { + const auto found = std::find_if(available.begin(), available.end(), [&](const auto& item) { + return std::strcmp(item.extensionName, name) == 0; + }); + if (found != available.end()) { + note(" %s: version %u", name, found->extensionVersion); + enabled.push_back(name); + } else { + note(" %s: MISSING", name); + } + } + // All of them, for the log only. + std::string all; + for (const auto& item : available) { + all += std::string{all.empty() ? "" : " "} + item.extensionName; + } + LOGI("xr probe: extensions: %s", all.c_str()); + if (level < 2) { + return env->NewStringUTF(report.c_str()); + } + + // An activity is what belongs here; there is none without somebody to show it to. Whether + // the runtime takes the app's context instead is part of what is being found out. + XrInstanceCreateInfoAndroidKHR android_info{XR_TYPE_INSTANCE_CREATE_INFO_ANDROID_KHR}; + android_info.applicationVM = vm; + android_info.applicationActivity = context; + XrInstanceCreateInfo instance_info{XR_TYPE_INSTANCE_CREATE_INFO}; + instance_info.next = &android_info; + std::strcpy(instance_info.applicationInfo.applicationName, "Astro VR Host"); + instance_info.applicationInfo.applicationVersion = 1; + instance_info.applicationInfo.apiVersion = XR_API_VERSION_1_0; + instance_info.enabledExtensionCount = static_cast<uint32_t>(enabled.size()); + instance_info.enabledExtensionNames = enabled.data(); + XrInstance instance = XR_NULL_HANDLE; + const XrResult create_result = xrCreateInstance(&instance_info, &instance); + note("instance created: %d", static_cast<int>(create_result)); + if (XR_FAILED(create_result)) { + return env->NewStringUTF(report.c_str()); + } + + XrInstanceProperties properties{XR_TYPE_INSTANCE_PROPERTIES}; + if (XR_SUCCEEDED(xrGetInstanceProperties(instance, &properties))) { + note("runtime: %s %u.%u.%u", properties.runtimeName, + static_cast<unsigned>(XR_VERSION_MAJOR(properties.runtimeVersion)), + static_cast<unsigned>(XR_VERSION_MINOR(properties.runtimeVersion)), + static_cast<unsigned>(XR_VERSION_PATCH(properties.runtimeVersion))); + } + + XrSystemGetInfo system_info{XR_TYPE_SYSTEM_GET_INFO}; + system_info.formFactor = XR_FORM_FACTOR_HEAD_MOUNTED_DISPLAY; + XrSystemId system = XR_NULL_SYSTEM_ID; + const XrResult system_result = xrGetSystem(instance, &system_info, &system); + note("system: %d", static_cast<int>(system_result)); + if (XR_SUCCEEDED(system_result)) { + XrSystemHandTrackingPropertiesEXT hands{XR_TYPE_SYSTEM_HAND_TRACKING_PROPERTIES_EXT}; + XrSystemProperties system_properties{XR_TYPE_SYSTEM_PROPERTIES}; + system_properties.next = &hands; + if (XR_SUCCEEDED(xrGetSystemProperties(instance, system, &system_properties))) { + note(" %s: swapchain images up to %ux%u, %u layers, hand tracking %d", + system_properties.systemName, + system_properties.graphicsProperties.maxSwapchainImageWidth, + system_properties.graphicsProperties.maxSwapchainImageHeight, + system_properties.graphicsProperties.maxLayerCount, + static_cast<int>(hands.supportsHandTracking)); + } + uint32_t view_count = 0; + XrViewConfigurationView views[2]{{XR_TYPE_VIEW_CONFIGURATION_VIEW}, + {XR_TYPE_VIEW_CONFIGURATION_VIEW}}; + if (XR_SUCCEEDED(xrEnumerateViewConfigurationViews( + instance, system, XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO, 2, &view_count, + views)) && + view_count == 2) { + note(" an eye: %ux%u recommended, %ux%u at most", + views[0].recommendedImageRectWidth, views[0].recommendedImageRectHeight, + views[0].maxImageRectWidth, views[0].maxImageRectHeight); + } + } + + const auto enumerate_counters = GetFunction<PFN_xrEnumeratePerformanceMetricsCounterPathsMETA>( + instance, "xrEnumeratePerformanceMetricsCounterPathsMETA"); + uint32_t counter_count = 0; + if (enumerate_counters != nullptr && + XR_SUCCEEDED(enumerate_counters(instance, 0, &counter_count, nullptr))) { + std::vector<XrPath> paths(counter_count); + enumerate_counters(instance, counter_count, &counter_count, paths.data()); + std::string names; + for (uint32_t i = 0; i < counter_count && i < paths.size(); ++i) { + char name[XR_MAX_PATH_LENGTH]{}; + uint32_t length = 0; + if (XR_SUCCEEDED(xrPathToString(instance, paths[i], sizeof(name), &length, name))) { + names += std::string{names.empty() ? "" : " "} + name; + } + } + note("%u performance counters: %s", counter_count, names.c_str()); + } + + xrDestroyInstance(instance); + note("%s", "instance destroyed"); + return env->NewStringUTF(report.c_str()); +} diff --git a/quest-host/java/com/astrobotquest/vrhost/MainActivity.java b/quest-host/java/com/astrobotquest/vrhost/MainActivity.java new file mode 100644 index 0000000..bdbda0b --- /dev/null +++ b/quest-host/java/com/astrobotquest/vrhost/MainActivity.java @@ -0,0 +1,1217 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +package com.astrobotquest.vrhost; + +import android.Manifest; +import android.app.Activity; +import android.content.pm.PackageManager; +import android.graphics.Bitmap; +import android.graphics.Canvas; +import android.graphics.Color; +import android.graphics.Paint; +import android.graphics.RectF; +import android.graphics.Typeface; +import android.hardware.Sensor; +import android.hardware.SensorEvent; +import android.hardware.SensorEventListener; +import android.hardware.SensorManager; +import android.hardware.input.InputManager; +import android.hardware.lights.Light; +import android.hardware.lights.LightState; +import android.hardware.lights.LightsManager; +import android.hardware.lights.LightsRequest; +import android.os.Build; +import android.os.Bundle; +import android.os.CombinedVibration; +import android.os.Handler; +import android.os.Looper; +import android.os.SystemClock; +import android.os.VibrationEffect; +import android.os.VibratorManager; +import android.util.Log; +import android.view.InputDevice; +import android.view.KeyEvent; +import android.view.MotionEvent; +import android.view.View; +import android.view.WindowManager; + +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.nio.ByteBuffer; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; + +/** + * Hosts the PS4 emulator core on a Meta Quest: installs its Linux runtime, starts it, feeds it a + * paired DualSense as the DualShock 4 the game expects (buttons, sticks, touchpad, motion + * sensors in; rumble and light bar colour out) and lets the native side show its frames in the + * headset. + * + * Files the user provides live in the app's external folder + * (/sdcard/Android/data/com.astrobotquest.vrhost/files): + * games/SERIAL/eboot.bin ... the extracted game (or /data/local/tmp/astro/games/SERIAL) + * data/shadPS4/ the emulator's own folder (sys_modules, saves, logs) + * vrhost.txt optional settings, see readSettings + * and what the app leaves there for looking at afterwards: + * host.log, core.log this app's log and the emulator's output of the last start + * host.prev.log, core.prev.log the same of the start before + */ +public class MainActivity extends Activity + implements InputManager.InputDeviceListener, SensorEventListener { + private static final String TAG = "AstroVR"; + + // PS4 pad button bits (ORBIS_PAD_BUTTON_*). + private static final int L3 = 0x2, R3 = 0x4, OPTIONS = 0x8; + private static final int UP = 0x10, RIGHT = 0x20, DOWN = 0x40, LEFT = 0x80; + private static final int L2 = 0x100, R2 = 0x200, L1 = 0x400, R1 = 0x800; + private static final int TRIANGLE = 0x1000, CIRCLE = 0x2000, CROSS = 0x4000, SQUARE = 0x8000; + private static final int TOUCHPAD = 0x100000; + + // The touchpad as the emulator takes it: the resolution of a DualSense's. + private static final int TOUCH_WIDTH = 1920, TOUCH_HEIGHT = 1080; + + private static final int STATUS_WIDTH = 1024, STATUS_HEIGHT = 512; + + /** Second place games are looked for; every app may read what adb puts there. */ + private static final String SHELL_GAMES = "/data/local/tmp/astro/games"; + + // Mirrors CoreProcess::State. + private static final int CORE_IDLE = 0, CORE_STARTING = 1, CORE_RUNNING = 2, CORE_STOPPED = 3, + CORE_FAILED = 4; + + /** How long a rumble command lasts if the game says nothing more, and how often it is renewed. */ + private static final int RUMBLE_MILLIS = 1000, RUMBLE_RENEW_MILLIS = 400; + + private static final int REQUEST_MICROPHONE = 1; + + static { + System.loadLibrary("astrovr"); + } + + private native void nativeStartXr(float refreshRate, int eyeWidth, int eyeHeight, + boolean trackHands, int sharpen, boolean cubic, boolean showStats, float predictMs, + int dynamicResolution, boolean cpuBoost); + + private native boolean nativeStartCore(String loader, String runtimeRoot, String storageRoot, + String game, String logFile, String[] extraArgs, String[] extraEnv); + + private native void nativeStop(); + + private native int nativeCoreState(); + + private native String nativeCoreMessage(); + + private native long nativeFrameCount(); + + private native void nativeSetStatusImage(ByteBuffer pixels); + + private native void nativeInput(int buttons, int leftX, int leftY, int rightX, int rightY, + int leftTrigger, int rightTrigger, boolean touchDown, int touchX, int touchY); + + private native void nativeMotion(float gx, float gy, float gz, float ax, float ay, float az); + + private native long nativePadFeedback(); + + private static final int VENDOR_SONY = 0x054c; + private static final int VENDOR_META = 0x2833; + + /** What a reset of the view covers: the controller's heading, the player's seat. */ + private static final int RECENTER_PAD = 1, RECENTER_SEAT = 2; + + private native void nativeRecenter(int what); + + private native int nativeXrStatus(); + + private native void nativeSetMicrophone(boolean enabled, float gain); + + private static native void nativeSetLogFile(String path); + + private static native void nativeLog(int priority, String message); + + private final Handler handler = new Handler(Looper.getMainLooper()); + private View inputView; + private volatile String setupStatus = "Starting..."; + private volatile boolean setupFailed; + private String shownStatus = ""; + + // Controller state. + private int keyButtons; + private int hatButtons; + private int triggerButtons; + private float leftX, leftY, rightX, rightY, leftTrigger, rightTrigger; + private boolean padTouchDown; + private float padTouchX, padTouchY; + private boolean padTouchClick; + private final float[] acceleration = {0.0f, 9.81f, 0.0f}; + + // The controller itself: what the game's feedback goes to. + private InputDevice gamepad; + private SensorManager controllerSensors; + private VibratorManager controllerVibrators; + private LightsManager.LightsSession lightSession; + private Light lightBar; + private long shownFeedback = -1; + private long rumbleRenewAt; + + // Settings. + private boolean stickTouchpad = true; + private boolean motion = true; + private boolean rumble = true; + private boolean trackHands = true; + private int sharpen = 1; + private boolean cubic; + private boolean antialias = true; + private int pace; + private int msaa = 1; + private boolean showStats; + private float predictMs = 25; + private boolean microphone = true; + private int dynamicResolution = 1; + private boolean cpuBoost = true; + /** + * How much of the PlayStation VR's field of view the game draws, in percent: less than all + * of it for more pixels to the degree, which is what the player asked for. + */ + private int fieldOfView = 85; + /** + * Set by the test that runs the activity without showing it (SandboxShell "drystart"): + * nothing is asked of the user or of the system's window manager then. + */ + private boolean dryRun; + private int statusPictures; + private float microphoneGain = 1.0f; + private boolean seatTaken; + /** How long OPTIONS is held for the view to be reset, as on a PlayStation VR. */ + private static final long OPTIONS_HOLD_MS = 1000; + private final Runnable optionsHeld = () -> { + logInfo("OPTIONS held: view reset"); + nativeRecenter(RECENTER_PAD | RECENTER_SEAT); + }; + private long quietFrames = -1; + private long quietSince; + private long statsFrames = -1; + private long statsTime; + private String statsRate = "..."; + private float refreshRate; + /** What SHADPS4_TITLE_RESOLUTION is set to, null to leave the choice to the emulator. */ + private String resolution; + private boolean realTime = true; + private final List<String> extraArgs = new ArrayList<>(); + private final List<String> extraEnv = new ArrayList<>(); + + @Override + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + dryRun = getIntent() != null && getIntent().getBooleanExtra("dry_run", false); + getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON); + + // Nothing is drawn here, the view only exists to receive controller events. + inputView = new View(this); + inputView.setFocusable(true); + inputView.setFocusableInTouchMode(true); + inputView.setOnCapturedPointerListener((view, event) -> handleTouchpad(event)); + setContentView(inputView); + inputView.requestFocus(); + + // Kept as files: by the time somebody asks what happened in a session, the system's + // log has long moved on. + File external = getExternalFilesDir(null); + keepPrevious(new File(external, "host.log"), new File(external, "host.prev.log")); + nativeSetLogFile(new File(external, "host.log").getAbsolutePath()); + logInfo("Astro VR Host " + versionName() + " on " + Build.MODEL + ", system " + + Build.DISPLAY); + + readSettings(); + nativeStartXr(refreshRate, 1440, 1536, trackHands, sharpen, cubic, showStats, predictMs, + dynamicResolution, cpuBoost); + nativeSetMicrophone(microphone, microphoneGain); + if (microphone && !dryRun && checkSelfPermission(Manifest.permission.RECORD_AUDIO) + != PackageManager.PERMISSION_GRANTED) { + // The game listens to the headset's microphone, as it did to PlayStation VR's: + // blowing at things is one of the ways to play with its world. + logInfo("asking for the microphone"); + requestPermissions(new String[] {Manifest.permission.RECORD_AUDIO}, + REQUEST_MICROPHONE); + } + + InputManager inputManager = getSystemService(InputManager.class); + inputManager.registerInputDeviceListener(this, handler); + findGamepad(); + + new Thread(this::setUpAndStart, "setup").start(); + handler.post(this::refreshStatus); + handler.post(this::applyFeedback); + } + + @Override + protected void onDestroy() { + handler.removeCallbacksAndMessages(null); + getSystemService(InputManager.class).unregisterInputDeviceListener(this); + detachGamepad(); + nativeStop(); + super.onDestroy(); + } + + @Override + public void onRequestPermissionsResult(int requestCode, String[] permissions, + int[] grantResults) { + super.onRequestPermissionsResult(requestCode, permissions, grantResults); + if (requestCode == REQUEST_MICROPHONE) { + // Nothing else to do: the native side keeps trying to open the microphone. + logInfo("microphone " + (grantResults.length > 0 + && grantResults[0] == PackageManager.PERMISSION_GRANTED + ? "allowed" : "not allowed")); + } + } + + /** Called by the native side when the headset session is over and will not come back. */ + private void onSessionEnded() { + logInfo("the session is over: closing"); + if (!dryRun) { + runOnUiThread(this::finish); + } + } + + private String versionName() { + try { + return getPackageManager().getPackageInfo(getPackageName(), 0).versionName; + } catch (PackageManager.NameNotFoundException e) { + return "?"; + } + } + + private static void keepPrevious(File current, File previous) { + if (current.isFile()) { + previous.delete(); + current.renameTo(previous); + } + } + + private static void logInfo(String message) { + nativeLog(Log.INFO, message); + } + + private static void logWarning(String message, Throwable cause) { + nativeLog(Log.WARN, cause == null ? message : message + ": " + cause); + } + + @Override + public void onWindowFocusChanged(boolean hasFocus) { + super.onWindowFocusChanged(hasFocus); + logInfo(hasFocus ? "input focus gained" : "input focus lost"); + if (hasFocus) { + // Gives the controller's touchpad to the game instead of a mouse pointer. + inputView.requestPointerCapture(); + } + } + + // --- settings ------------------------------------------------------------------------------- + + /** + * Reads the optional vrhost.txt: one "key=value" per line. + * refresh_rate=72 display refresh rate to ask for (72, 80, 90, 120). The game + * draws one frame for every two refreshes where the GPU manages + * that, and one for every three where it does not: 45 or 30 + * frames a second at the 90 Hz asked for without this, and 60, + * 40 or 30 at 120. At 72 and 80 Hz there is only the one pace + * (36, 40): frames are never given more refreshes than still + * makes 30 a second, below that the game draws as it can + * pace=2 leave it to the game how many refreshes a frame takes, as up to + * version 0.6: it takes two, and one more whenever a frame is + * late, so frames last unevenly where it only just keeps up. A + * larger number holds every frame to that many refreshes. Without + * this the emulator chooses, see resolution + * resolution=960 the size the game draws its scene at, per eye: 816 (x870), 960 + * (x1080), 1200 (x1280) or 1440 (x1536), or "game" for the game's + * own choice. Without this the emulator chooses: the fastest pace + * at which 960x1080 (the console's own smallest) fits the GPU's + * time, 816x870 only where that would mean fewer than 30 frames a + * second, and then the largest size that fits that pace + * antialias=0 leave edges as jagged as the game draws them here. The console + * multisamples (see msaa), which this GPU cannot afford; by + * default the emulator smooths edges in the finished scene + * instead, for a fraction of the cost + * real_time=0 let the game count time in frames, as it does on the console: + * it then runs in slow motion whenever a frame takes longer than + * a sixtieth of a second, which here is always. By default the + * emulator has it run by the clock + * hands=0 do not use hand tracking to place the controller; it is then held + * at a fixed spot in front of the player + * sharpen=0 leave the picture as soft as it gets from being shown larger + * than it was drawn. By default (1) the emulator sharpens it once + * per frame of the game. 2 has the headset do it instead, with its + * Super Resolution filter on every refresh: finer, but it takes + * about a twentieth of the GPU from the game. 3 is the same left + * to the system, which drops it when the GPU is busy (always, in + * a level). 4 is the headset's plainer filter + * cubic=1 have the headset enlarge the picture with a cubic filter instead + * of a linear one: sharper, for some GPU time on every refresh + * stick_touchpad=0 stop using the right stick as a finger on the touchpad + * motion=0 ignore the controller's motion sensors + * rumble=0 no vibration + * msaa=4 let the game multisample as it does on the console (1, 2 or 4). + * The default of 1 turns that off: it is by far the most expensive + * thing the headset's GPU is asked to do + * stats=1 keep a small panel in view with the game's frame rate, the + * display's refresh rate and whether the hands are seen + * predict_ms=25 how far beyond the next refresh the head pose given to the game + * is predicted (0 to 80). More if the edges of the picture show + * when turning the head, less if the world wobbles + * dynamic_resolution=0 do not ask the system what size it recommends for the + * picture. Asking is what the system wants of an app before it + * lets the GPU run at its faster clocks; the picture is shown at + * full size all the same (the game draws its scene smaller when + * the GPU is short, which is what saves time). 2 also shows the + * picture at the recommended size, as up to version 0.6 + * cpu_boost=0 do not ask for the processor's fastest clock, which the system + * otherwise grants for the first 45 seconds and now and then + * fov=100 have the game draw that many percent of the field of view it + * draws on a PlayStation VR (100 by 103 degrees an eye), and show + * it over that much: the same pixels over fewer degrees is a sharper + * picture, with a black border where the rest was. Default 85 (18% + * more pixels to the degree); 100 is the console's own, 50 to 120 + * mic=0 the game does not get to hear the headset's microphone + * mic_gain=2 make what it hears that many times louder (0.1 to 30), if + * blowing does too little or everything counts as blowing + * arg=... extra emulator argument (may repeat) + * env=NAME=value extra emulator environment variable (may repeat) + */ + private void readSettings() { + File file = new File(getExternalFilesDir(null), "vrhost.txt"); + // The test that starts the activity without showing it may bring settings of its own. + String testSettings = dryRun ? getIntent().getStringExtra("settings") : null; + if (testSettings != null) { + file = new File(testSettings); + } + if (!file.isFile()) { + return; + } + try { + for (String line : Files.readAllLines(file.toPath(), StandardCharsets.UTF_8)) { + line = line.trim(); + int equals = line.indexOf('='); + if (line.isEmpty() || line.startsWith("#") || equals <= 0) { + continue; + } + String key = line.substring(0, equals).trim(); + String value = line.substring(equals + 1).trim(); + switch (key) { + case "refresh_rate": + refreshRate = Float.parseFloat(value); + break; + case "resolution": + switch (value) { + case "816": + resolution = "3"; + break; + case "960": + resolution = "4"; + break; + case "1200": + resolution = "5"; + break; + case "1440": + resolution = "6"; + break; + case "game": + resolution = "title"; + break; + default: + resolution = null; + break; + } + break; + case "real_time": + realTime = !value.equals("0"); + break; + case "hands": + trackHands = !value.equals("0"); + break; + case "sharpen": + sharpen = Math.max(0, Math.min(4, Integer.parseInt(value))); + break; + case "cubic": + cubic = !value.equals("0"); + break; + case "antialias": + antialias = !value.equals("0"); + break; + case "pace": + pace = Math.max(0, Math.min(6, Integer.parseInt(value))); + break; + case "stick_touchpad": + stickTouchpad = !value.equals("0"); + break; + case "motion": + motion = !value.equals("0"); + break; + case "rumble": + rumble = !value.equals("0"); + break; + case "stats": + showStats = !value.equals("0"); + break; + case "predict_ms": + predictMs = Math.max(0, Math.min(80, Float.parseFloat(value))); + break; + case "msaa": + msaa = Math.max(1, Math.min(4, Integer.parseInt(value))); + break; + case "dynamic_resolution": + dynamicResolution = Math.max(0, Math.min(2, Integer.parseInt(value))); + break; + case "cpu_boost": + cpuBoost = !value.equals("0"); + break; + case "fov": + fieldOfView = Math.max(50, Math.min(120, Integer.parseInt(value))); + break; + case "mic": + microphone = !value.equals("0"); + break; + case "mic_gain": + microphoneGain = Math.max(0.1f, Math.min(30.0f, Float.parseFloat(value))); + break; + case "arg": + extraArgs.add(value); + break; + case "env": + extraEnv.add(value); + break; + default: + logWarning("unknown setting " + key, null); + continue; + } + logInfo("setting " + key + "=" + value); + } + } catch (IOException | NumberFormatException e) { + logWarning("unable to read " + file, e); + } + } + + // --- runtime and game ----------------------------------------------------------------------- + + private void setUpAndStart() { + try { + // On the first start, and after every update of the app: a few seconds. + File runtime = new File(getFilesDir(), "runtime"); + setupStatus = "Installing the emulator runtime..."; + if (RuntimeInstaller.install(this, runtime)) { + logInfo("runtime unpacked"); + } + + File external = getExternalFilesDir(null); + File games = new File(external, "games"); + games.mkdirs(); + new File(external, "data/shadPS4/sys_modules").mkdirs(); + File eboot = findGame(games); + if (eboot == null) { + // Where "adb push" can put it without caring who owns the files. + eboot = findGame(new File(SHELL_GAMES)); + } + if (eboot == null) { + setupFailed = true; + setupStatus = "No game found.\n\nCopy the extracted game folder (the one that " + + "contains eboot.bin) to the headset, to either of\n" + games + + "/CUSA12392\n" + SHELL_GAMES + "/CUSA12392\nthen start this app again."; + return; + } + + File storage = new File(getFilesDir(), "core"); + storage.mkdirs(); + // Settings from vrhost.txt come last: they replace what is set here. + List<String> env = new ArrayList<>(); + // Saves, firmware modules and logs go where the user can reach them over USB. + env.add("XDG_DATA_HOME=" + new File(external, "data")); + env.add("SHADPS4_MAX_MSAA=" + msaa); + // The emulator has more busy threads than the headset has processor cores for it. + // The sound must not stutter for that (the game mixes it on two threads, the + // emulator passes it on with one per output), a frame should not wait behind the + // game's helpers on the two threads all of it passes through, and the two that + // keep time with the display (they have next to nothing to do) must do so on time. + env.add("SHADPS4_THREAD_NICE=Game:Main=-14,shadPS4:GpuComm=-14,sndx_out_thread=-16," + + "sndx_audio3d=-16,shadPS4:AudioOu=-16,shadPS4:VrHostL=-18," + + "shadPS4:Present=-18"); + // On the GPU the emulator steps back behind this app: copying a finished picture + // to the display takes a millisecond, and must not wait until the GPU is through + // with everything the game has queued for the pictures after it. + env.add("KGSL_COMPAT_PRIORITY=12"); + if (msaa == 1) { + // Without multisampling the GPU driver's direct rendering is the faster of its + // two ways to draw (about 5% of the GPU's time with this game); its own choice + // per render pass goes for the tiled way too often. + env.add("TU_DEBUG=sysmem"); + } + // A few lines every five or ten seconds in core.log: the frame rate and where a + // frame's time goes, how well each sound port keeps up, what the microphone hears. + env.add("SHADPS4_FRAME_STATS=1"); + env.add("SHADPS4_AUDIOOUT_STATS=1"); + env.add("SHADPS4_AUDIOIN_STATS=1"); + // The emulated headset refreshes as often as the display does (and, once frames + // are shown, when it does): the game draws one frame for every two refreshes, or + // for every three where that is all the GPU manages. + int displayRate = (nativeXrStatus() >> 8) & 0xff; + if (displayRate == 0) { + displayRate = refreshRate > 0 ? Math.round(refreshRate) : 90; + } + env.add("SHADPS4_VR_REFRESH_RATE=" + displayRate); + logInfo("the emulated headset refreshes " + displayRate + " times a second"); + if (resolution != null) { + env.add("SHADPS4_TITLE_RESOLUTION=" + resolution); + } + if (!realTime) { + env.add("SHADPS4_TITLE_TIMESTEP=0"); + } + if (pace >= 2) { + env.add("SHADPS4_VR_PACE=" + pace); + } + if (fieldOfView != 100) { + env.add("SHADPS4_VR_FOV=" + fieldOfView); + } + double angle = Math.toDegrees(Math.atan(1.2074 * fieldOfView / 100.0) + + Math.atan(1.1813 * fieldOfView / 100.0)); + logInfo("the game draws " + fieldOfView + "% of PlayStation VR's field of view: " + + Math.round(angle) + " degrees across an eye, " + + Math.round(1440 / angle * 10) / 10.0 + " pixels to the degree at most" + + " (fov= in vrhost.txt; 100 is the console's own)"); + if (!antialias) { + env.add("SHADPS4_RESOLVE_AA=0"); + } + if (sharpen == 1) { + // The game draws 1440 pixels across for what the display shows with well over + // twice as many, and enlarges its scene to get even there. + env.add("SHADPS4_VR_SHARPEN=0.6"); + } + env.addAll(extraEnv); + + setupStatus = "Starting the emulator..."; + keepPrevious(new File(external, "core.log"), new File(external, "core.prev.log")); + logInfo("game: " + eboot); + String loader = getApplicationInfo().nativeLibraryDir + "/libastro_ld.so"; + boolean started = nativeStartCore(loader, runtime.getAbsolutePath(), + storage.getAbsolutePath(), eboot.getAbsolutePath(), + new File(external, "core.log").getAbsolutePath(), + extraArgs.toArray(new String[0]), env.toArray(new String[0])); + if (!started) { + setupFailed = true; + setupStatus = "The emulator could not be started."; + } + } catch (IOException e) { + nativeLog(Log.ERROR, "setup failed: " + e); + setupFailed = true; + setupStatus = "Setup failed: " + e.getMessage(); + } + } + + /** The game to run: games/CUSA12392 if present, otherwise the first folder with an eboot. */ + private static File findGame(File games) { + File preferred = new File(games, "CUSA12392/eboot.bin"); + if (preferred.isFile()) { + return preferred; + } + File[] folders = games.listFiles(); + if (folders != null) { + for (File folder : folders) { + File eboot = new File(folder, "eboot.bin"); + if (eboot.isFile()) { + return eboot; + } + } + } + return null; + } + + // --- status panel --------------------------------------------------------------------------- + + private void refreshStatus() { + String status = setupStatus; + if (!setupFailed) { + switch (nativeCoreState()) { + case CORE_STARTING: + status = "Starting the emulator..."; + break; + case CORE_RUNNING: + status = nativeFrameCount() == 0 ? "Booting the game..." : "Loading..."; + if (showStats && nativeFrameCount() > 0) { + status = statsLine(); + } + // A game that stopped drawing looks like one that loads. Loads end. + long frames = nativeFrameCount(); + long now = SystemClock.elapsedRealtime(); + if (frames != quietFrames) { + quietFrames = frames; + quietSince = now; + } + long quiet = (now - quietSince) / 1000; + if (frames > 0 && quiet >= 20) { + status = "No new picture from the game for " + quiet / 5 * 5 + + " seconds.\nA long load looks like this too. Past a minute the " + + "game is stuck: close the app with the Meta button and start it " + + "again. What happened is kept in host.log and core.log."; + } + break; + case CORE_STOPPED: + case CORE_FAILED: + status = nativeCoreMessage() + "\n\nLog: " + + new File(getExternalFilesDir(null), "core.log"); + break; + default: + break; + } + // Waiting is the moment to say what the game will be played with. + if (gamepad == null) { + status += "\n\nNo controller found. Switch the DualSense on (PS button); pair it " + + "first under Settings > Bluetooth if it never was."; + } else { + status += "\n\nController: " + gamepad.getName() + + (controllerSensors != null ? "" : " (no motion sensors)") + + "\nTo reset the view, hold OPTIONS for a second or press the PS button: " + + "where you are then is your seat, and the way you face is straight " + + "ahead."; + } + } + if (!status.equals(shownStatus)) { + shownStatus = status; + drawStatus(status); + } + handler.postDelayed(this::refreshStatus, 500); + } + + /** What the game and the display are doing, for the panel that stats=1 keeps in view. */ + private String statsLine() { + long frames = nativeFrameCount(); + long now = SystemClock.elapsedRealtime(); + if (statsFrames < 0) { + statsFrames = frames; + statsTime = now; + } else if (now - statsTime >= 2000) { + // Over two seconds: a rate counted over less jumps about. + statsRate = String.format(Locale.US, "%.0f", + (frames - statsFrames) * 1000.0 / (now - statsTime)); + statsFrames = frames; + statsTime = now; + } + String rate = statsRate; + int xr = nativeXrStatus(); + return "Game: " + rate + " frames a second\nDisplay: " + ((xr >> 8) & 0xff) + " Hz\n" + + "Hands holding the controller: " + ((xr & 2) != 0 ? "seen" : "not seen"); + } + + private void drawStatus(String status) { + Bitmap bitmap = Bitmap.createBitmap(STATUS_WIDTH, STATUS_HEIGHT, Bitmap.Config.ARGB_8888); + Canvas canvas = new Canvas(bitmap); + Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG); + paint.setColor(Color.argb(230, 16, 20, 32)); + canvas.drawRoundRect(new RectF(0, 0, STATUS_WIDTH, STATUS_HEIGHT), 40, 40, paint); + + paint.setColor(Color.rgb(90, 170, 255)); + paint.setTypeface(Typeface.create(Typeface.DEFAULT, Typeface.BOLD)); + paint.setTextSize(52); + canvas.drawText("Astro VR Host", 48, 86, paint); + + paint.setColor(Color.WHITE); + paint.setTypeface(Typeface.DEFAULT); + paint.setTextSize(30); + float y = 160; + for (String paragraph : status.split("\n")) { + // Wrap by measuring: at a space where there is one, anywhere where there is none + // (paths have no spaces to break at). + String rest = paragraph; + do { + int count = paint.breakText(rest, true, STATUS_WIDTH - 96, null); + if (count < rest.length()) { + int space = rest.lastIndexOf(' ', count); + if (space > 0) { + count = space + 1; + } + } + canvas.drawText(rest, 0, count, 48, y, paint); + rest = rest.substring(count); + y += 40; + } while (!rest.isEmpty()); + } + + if (dryRun && statusPictures < 8) { + // Nobody sees the panel in a test: its pictures are kept for looking at, in the + // folder the test has made for them. + File picture = new File(new File(getFilesDir(), "drystart"), + "status-" + statusPictures++ + ".png"); + try (FileOutputStream out = new FileOutputStream(picture)) { + bitmap.compress(Bitmap.CompressFormat.PNG, 100, out); + } catch (IOException e) { + logWarning("unable to write " + picture, e); + } + } + + ByteBuffer pixels = ByteBuffer.allocateDirect(STATUS_WIDTH * STATUS_HEIGHT * 4); + bitmap.copyPixelsToBuffer(pixels); + nativeSetStatusImage(pixels); + bitmap.recycle(); + } + + // --- controller: buttons and sticks --------------------------------------------------------- + + private static int buttonFor(int keyCode) { + switch (keyCode) { + case KeyEvent.KEYCODE_BUTTON_A: + return CROSS; + case KeyEvent.KEYCODE_BUTTON_B: + return CIRCLE; + case KeyEvent.KEYCODE_BUTTON_X: + return SQUARE; + case KeyEvent.KEYCODE_BUTTON_Y: + return TRIANGLE; + case KeyEvent.KEYCODE_BUTTON_L1: + return L1; + case KeyEvent.KEYCODE_BUTTON_R1: + return R1; + case KeyEvent.KEYCODE_BUTTON_L2: + return L2; + case KeyEvent.KEYCODE_BUTTON_R2: + return R2; + case KeyEvent.KEYCODE_BUTTON_THUMBL: + return L3; + case KeyEvent.KEYCODE_BUTTON_THUMBR: + return R3; + case KeyEvent.KEYCODE_BUTTON_START: + return OPTIONS; + // The Create button stands in for a click of the touchpad as well. + case KeyEvent.KEYCODE_BUTTON_SELECT: + case KeyEvent.KEYCODE_BUTTON_1: + return TOUCHPAD; + case KeyEvent.KEYCODE_DPAD_UP: + return UP; + case KeyEvent.KEYCODE_DPAD_RIGHT: + return RIGHT; + case KeyEvent.KEYCODE_DPAD_DOWN: + return DOWN; + case KeyEvent.KEYCODE_DPAD_LEFT: + return LEFT; + default: + return 0; + } + } + + @Override + public boolean dispatchKeyEvent(KeyEvent event) { + if (event.getKeyCode() == KeyEvent.KEYCODE_BUTTON_MODE) { + // The PS button resets the view: where the head is now is where the player sits, + // the way they face is straight ahead, and so is the way the controller points + // (which only matters while the headset does not see the hands holding it). + if (event.getAction() == KeyEvent.ACTION_DOWN && event.getRepeatCount() == 0) { + logInfo("PS button: view reset"); + nativeRecenter(RECENTER_PAD | RECENTER_SEAT); + } + return true; + } + int button = buttonFor(event.getKeyCode()); + if (button == 0) { + return super.dispatchKeyEvent(event); + } + if (event.getAction() == KeyEvent.ACTION_DOWN) { + noteInputFrom(event.getDevice()); + if (button == CROSS && !seatTaken) { + // The first press of X is the player settled in, controller in hand, looking + // at the game: that, and not where they were when the app started, is their + // seat. + seatTaken = true; + logInfo("first press of X: the player's seat is where they are now"); + nativeRecenter(RECENTER_SEAT); + } + if (button == OPTIONS && event.getRepeatCount() == 0) { + // What a PlayStation VR does when OPTIONS is held, and what the game tells its + // players to do when the view is off. The game still sees the button. + handler.removeCallbacks(optionsHeld); + handler.postDelayed(optionsHeld, OPTIONS_HOLD_MS); + } + keyButtons |= button; + } else if (event.getAction() == KeyEvent.ACTION_UP) { + if (button == OPTIONS) { + handler.removeCallbacks(optionsHeld); + } + keyButtons &= ~button; + } + sendInput(); + return true; + } + + private static float axis(MotionEvent event, int axis) { + InputDevice.MotionRange range = event.getDevice() != null + ? event.getDevice().getMotionRange(axis, InputDevice.SOURCE_JOYSTICK) : null; + float value = event.getAxisValue(axis); + // Sticks rest slightly off centre. + return range != null && Math.abs(value) <= range.getFlat() ? 0.0f : value; + } + + @Override + public boolean dispatchGenericMotionEvent(MotionEvent event) { + if (event.isFromSource(InputDevice.SOURCE_JOYSTICK) + && event.getAction() == MotionEvent.ACTION_MOVE) { + leftX = axis(event, MotionEvent.AXIS_X); + leftY = axis(event, MotionEvent.AXIS_Y); + rightX = axis(event, MotionEvent.AXIS_Z); + rightY = axis(event, MotionEvent.AXIS_RZ); + leftTrigger = Math.max(event.getAxisValue(MotionEvent.AXIS_LTRIGGER), + event.getAxisValue(MotionEvent.AXIS_BRAKE)); + rightTrigger = Math.max(event.getAxisValue(MotionEvent.AXIS_RTRIGGER), + event.getAxisValue(MotionEvent.AXIS_GAS)); + + float hatX = event.getAxisValue(MotionEvent.AXIS_HAT_X); + float hatY = event.getAxisValue(MotionEvent.AXIS_HAT_Y); + hatButtons = (hatX < -0.5f ? LEFT : 0) | (hatX > 0.5f ? RIGHT : 0) + | (hatY < -0.5f ? UP : 0) | (hatY > 0.5f ? DOWN : 0); + triggerButtons = (leftTrigger > 0.12f ? L2 : 0) | (rightTrigger > 0.12f ? R2 : 0); + sendInput(); + return true; + } + if (handleTouchpad(event)) { + return true; + } + return super.dispatchGenericMotionEvent(event); + } + + /** The controller's own touchpad, when the system exposes it with finger positions. */ + private boolean handleTouchpad(MotionEvent event) { + if (!event.isFromSource(InputDevice.SOURCE_TOUCHPAD) || event.getDevice() == null) { + return false; + } + // Sticks and touchpad are one device with two meanings for X and Y. + InputDevice.MotionRange rangeX = event.getDevice().getMotionRange(MotionEvent.AXIS_X, + InputDevice.SOURCE_TOUCHPAD); + InputDevice.MotionRange rangeY = event.getDevice().getMotionRange(MotionEvent.AXIS_Y, + InputDevice.SOURCE_TOUCHPAD); + if (rangeX == null || rangeY == null || rangeX.getRange() <= 0 || rangeY.getRange() <= 0) { + return false; + } + switch (event.getActionMasked()) { + case MotionEvent.ACTION_DOWN: + case MotionEvent.ACTION_MOVE: + padTouchDown = true; + padTouchX = (event.getX() - rangeX.getMin()) / rangeX.getRange(); + padTouchY = (event.getY() - rangeY.getMin()) / rangeY.getRange(); + break; + case MotionEvent.ACTION_UP: + case MotionEvent.ACTION_CANCEL: + padTouchDown = false; + break; + default: + break; + } + padTouchClick = (event.getButtonState() & MotionEvent.BUTTON_PRIMARY) != 0; + sendInput(); + return true; + } + + private static int stick(float value) { + return Math.max(0, Math.min(255, Math.round(128.0f + value * 127.0f))); + } + + private void sendInput() { + int buttons = keyButtons | hatButtons | triggerButtons | (padTouchClick ? TOUCHPAD : 0); + + boolean touchDown = padTouchDown; + float touchX = padTouchX, touchY = padTouchY; + if (!touchDown && stickTouchpad) { + // This title has no use for the right stick, while several of its gadgets want + // swipes: the stick moves a finger that touches down at the pad's centre. + float deflection = (float) Math.hypot(rightX, rightY); + if (deflection > 0.25f) { + touchDown = true; + touchX = 0.5f + rightX * 0.45f; + touchY = 0.5f + rightY * 0.45f; + } + } + + nativeInput(buttons, stick(leftX), stick(leftY), stick(rightX), stick(rightY), + Math.round(Math.max(0.0f, Math.min(1.0f, leftTrigger)) * 255.0f), + Math.round(Math.max(0.0f, Math.min(1.0f, rightTrigger)) * 255.0f), touchDown, + Math.max(0, Math.min(TOUCH_WIDTH - 1, Math.round(touchX * (TOUCH_WIDTH - 1)))), + Math.max(0, Math.min(TOUCH_HEIGHT - 1, Math.round(touchY * (TOUCH_HEIGHT - 1))))); + } + + // --- controller: the device, its motion sensors, rumble and light ---------------------------- + + private static boolean isGamepad(InputDevice device) { + return device != null && !device.isVirtual() + && device.supportsSource(InputDevice.SOURCE_GAMEPAD) + && device.supportsSource(InputDevice.SOURCE_JOYSTICK); + } + + /** + * How much a device looks like the controller the game is played with. The headset's own + * controllers also show up as gamepads (and come first in the list when the app was started + * with one of them): a controller from the console's maker goes before anything else, the + * headset's own after everything else, and motion sensors and motors count for the rest. + */ + private int rank(InputDevice device) { + int rank = 0; + if (device.getVendorId() == VENDOR_SONY) { + rank += 8; + } else if (device.getVendorId() == VENDOR_META) { + rank -= 8; + } + try { + if (findSensors(device) != null) { + rank += 2; + } + if (device.getVibratorManager().getVibratorIds().length > 0) { + rank += 1; + } + } catch (RuntimeException e) { + // A device that cannot say what it has is ranked by its maker alone. + } + return rank; + } + + private void findGamepad() { + InputManager inputManager = getSystemService(InputManager.class); + InputDevice best = gamepad; + for (int id : inputManager.getInputDeviceIds()) { + InputDevice device = inputManager.getInputDevice(id); + if (isGamepad(device) && (best == null || rank(device) > rank(best))) { + best = device; + } + } + useGamepad(best); + } + + /** Makes `device` the controller, if it is not that already. */ + private void useGamepad(InputDevice device) { + if (device == null || (gamepad != null && gamepad.getId() == device.getId())) { + return; + } + if (gamepad != null) { + logInfo("another controller takes over"); + detachGamepad(); + } + attachGamepad(device); + } + + /** + * Buttons and sticks are taken from whichever gamepad they come from. If that is not the + * device taken for the controller, and it looks no less like one, it is the controller from + * now on: its motion sensors, motors and light are the ones to use. + */ + private void noteInputFrom(InputDevice device) { + if (gamepad != null && device != null && device.getId() == gamepad.getId()) { + return; + } + if (isGamepad(device) && (gamepad == null || rank(device) >= rank(gamepad))) { + useGamepad(device); + } + } + + private void attachGamepad(InputDevice device) { + gamepad = device; + logInfo("controller: " + device.getName() + " (vendor " + device.getVendorId() + + ", product " + device.getProductId() + ", sources 0x" + + Integer.toHexString(device.getSources()) + ")"); + + // Every part is optional: what a controller offers depends on it and on the system. + try { + SensorManager sensors = motion ? findSensors(device) : null; + if (sensors != null) { + sensors.registerListener(this, sensors.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), + SensorManager.SENSOR_DELAY_FASTEST); + sensors.registerListener(this, sensors.getDefaultSensor(Sensor.TYPE_GYROSCOPE), + SensorManager.SENSOR_DELAY_FASTEST); + controllerSensors = sensors; + } + } catch (RuntimeException e) { + logWarning("no motion sensors", e); + } + try { + VibratorManager vibrators = device.getVibratorManager(); + if (rumble && vibrators.getVibratorIds().length > 0) { + controllerVibrators = vibrators; + } + } catch (RuntimeException e) { + logWarning("no rumble", e); + } + try { + LightsManager lights = device.getLightsManager(); + for (Light light : lights.getLights()) { + if (light.hasRgbControl()) { + lightBar = light; + lightSession = lights.openSession(); + break; + } + } + } catch (RuntimeException e) { + logWarning("no light bar", e); + } + logInfo("controller offers: motion " + (controllerSensors != null) + ", rumble " + + (controllerVibrators != null) + ", light bar " + (lightBar != null) + + ", touchpad " + device.supportsSource(InputDevice.SOURCE_TOUCHPAD)); + shownFeedback = -1; + } + + /** + * The motion sensors of a controller. The system normally presents them as part of the + * gamepad; where it lists them as a device of their own, that one is found by its maker + * and model. + */ + private SensorManager findSensors(InputDevice device) { + InputManager inputManager = getSystemService(InputManager.class); + List<InputDevice> candidates = new ArrayList<>(); + candidates.add(device); + for (int id : inputManager.getInputDeviceIds()) { + InputDevice other = inputManager.getInputDevice(id); + if (other != null && other.getId() != device.getId() + && other.getVendorId() == device.getVendorId() + && other.getProductId() == device.getProductId()) { + candidates.add(other); + } + } + for (InputDevice candidate : candidates) { + SensorManager sensors = candidate.getSensorManager(); + if (sensors.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) != null + && sensors.getDefaultSensor(Sensor.TYPE_GYROSCOPE) != null) { + return sensors; + } + } + return null; + } + + private void detachGamepad() { + if (controllerSensors != null) { + controllerSensors.unregisterListener(this); + controllerSensors = null; + } + if (controllerVibrators != null) { + try { + controllerVibrators.cancel(); + } catch (RuntimeException e) { + // The controller is gone, and its motors with it. + } + controllerVibrators = null; + } + if (lightSession != null) { + try { + lightSession.close(); + } catch (RuntimeException e) { + // Likewise. + } + lightSession = null; + } + lightBar = null; + gamepad = null; + } + + /** Carries out what the game last asked of the controller: rumble and light bar colour. */ + private void applyFeedback() { + long feedback = nativePadFeedback(); + long now = android.os.SystemClock.uptimeMillis(); + int small = (int) (feedback & 0xff); + int large = (int) ((feedback >> 8) & 0xff); + boolean changed = feedback != shownFeedback; + + if (controllerVibrators != null + && (changed || ((small | large) != 0 && now >= rumbleRenewAt))) { + try { + int[] ids = controllerVibrators.getVibratorIds(); + if ((small | large) == 0) { + controllerVibrators.cancel(); + } else { + // The first motor is the heavy one, as the system lists them. + CombinedVibration.ParallelCombination both = CombinedVibration.startParallel(); + if (ids.length == 1) { + both.addVibrator(ids[0], VibrationEffect.createOneShot(RUMBLE_MILLIS, + Math.max(small, large))); + } else { + if (large != 0) { + both.addVibrator(ids[0], + VibrationEffect.createOneShot(RUMBLE_MILLIS, large)); + } + if (small != 0) { + both.addVibrator(ids[1], + VibrationEffect.createOneShot(RUMBLE_MILLIS, small)); + } + } + controllerVibrators.vibrate(both.combine()); + rumbleRenewAt = now + RUMBLE_RENEW_MILLIS; + } + } catch (RuntimeException e) { + logWarning("rumble failed", e); + controllerVibrators = null; + } + } + + if (changed && lightSession != null && lightBar != null) { + int red = (int) ((feedback >> 16) & 0xff); + int green = (int) ((feedback >> 24) & 0xff); + int blue = (int) ((feedback >> 32) & 0xff); + // Before the game has chosen a colour the bar keeps the one the system gave it. + if ((red | green | blue) != 0) { + try { + lightSession.requestLights(new LightsRequest.Builder() + .addLight(lightBar, new LightState.Builder() + .setColor(Color.rgb(red, green, blue)).build()) + .build()); + } catch (RuntimeException e) { + logWarning("light bar failed", e); + lightSession = null; + } + } + } + shownFeedback = feedback; + handler.postDelayed(this::applyFeedback, 16); + } + + @Override + public void onSensorChanged(SensorEvent event) { + if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) { + System.arraycopy(event.values, 0, acceleration, 0, 3); + } else if (event.sensor.getType() == Sensor.TYPE_GYROSCOPE) { + nativeMotion(event.values[0], event.values[1], event.values[2], acceleration[0], + acceleration[1], acceleration[2]); + } + } + + @Override + public void onAccuracyChanged(Sensor sensor, int accuracy) {} + + @Override + public void onInputDeviceAdded(int deviceId) { + // A controller that is switched on later takes over from a lesser one found before. + findGamepad(); + adoptLateSensors(); + } + + /** The motion sensors of a controller may be listed a moment after the controller. */ + private void adoptLateSensors() { + if (gamepad == null || controllerSensors != null || !motion) { + return; + } + InputDevice device = getSystemService(InputManager.class).getInputDevice(gamepad.getId()); + if (device != null && findSensors(device) != null) { + detachGamepad(); + attachGamepad(device); + } + } + + @Override + public void onInputDeviceRemoved(int deviceId) { + if (gamepad != null && gamepad.getId() == deviceId) { + logInfo("controller gone"); + detachGamepad(); + // Nothing is held down on a controller that is gone. + keyButtons = 0; + hatButtons = 0; + triggerButtons = 0; + leftX = leftY = rightX = rightY = leftTrigger = rightTrigger = 0.0f; + padTouchDown = false; + padTouchClick = false; + sendInput(); + findGamepad(); + } + } + + @Override + public void onInputDeviceChanged(int deviceId) { + adoptLateSensors(); + } +} diff --git a/quest-host/java/com/astrobotquest/vrhost/RuntimeInstaller.java b/quest-host/java/com/astrobotquest/vrhost/RuntimeInstaller.java new file mode 100644 index 0000000..4b0464b --- /dev/null +++ b/quest-host/java/com/astrobotquest/vrhost/RuntimeInstaller.java @@ -0,0 +1,82 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +package com.astrobotquest.vrhost; + +import android.content.Context; + +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.util.zip.ZipEntry; +import java.util.zip.ZipInputStream; + +/** + * Unpacks the Linux runtime the emulator runs in (its libraries, the GPU driver, the emulator + * core itself) from the app's assets into the app's files folder. The assets carry a stamp of + * what they hold; a folder with the same stamp is left alone. + */ +final class RuntimeInstaller { + private RuntimeInstaller() {} + + /** Returns true when the runtime had to be unpacked, false when it was there already. */ + static boolean install(Context context, File runtime) throws IOException { + String stamp; + try (InputStream in = context.getAssets().open("runtime.stamp")) { + stamp = new String(readAll(in), StandardCharsets.UTF_8).trim(); + } + File stampFile = new File(runtime, ".stamp"); + if (stampFile.isFile() + && new String(Files.readAllBytes(stampFile.toPath()), StandardCharsets.UTF_8) + .trim().equals(stamp)) { + return false; + } + + deleteRecursively(runtime); + runtime.mkdirs(); + String root = runtime.getCanonicalPath() + File.separator; + byte[] buffer = new byte[1 << 16]; + try (ZipInputStream zip = new ZipInputStream(context.getAssets().open("runtime.zip"))) { + for (ZipEntry entry = zip.getNextEntry(); entry != null; entry = zip.getNextEntry()) { + File target = new File(runtime, entry.getName()); + if (!target.getCanonicalPath().startsWith(root)) { + throw new IOException("bad runtime entry " + entry.getName()); + } + if (entry.isDirectory()) { + target.mkdirs(); + continue; + } + target.getParentFile().mkdirs(); + try (FileOutputStream out = new FileOutputStream(target)) { + for (int count = zip.read(buffer); count > 0; count = zip.read(buffer)) { + out.write(buffer, 0, count); + } + } + target.setExecutable(true, true); + } + } + Files.write(stampFile.toPath(), stamp.getBytes(StandardCharsets.UTF_8)); + return true; + } + + private static byte[] readAll(InputStream in) throws IOException { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + byte[] buffer = new byte[4096]; + for (int count = in.read(buffer); count > 0; count = in.read(buffer)) { + out.write(buffer, 0, count); + } + return out.toByteArray(); + } + + static void deleteRecursively(File file) { + File[] children = file.listFiles(); + if (children != null) { + for (File child : children) { + deleteRecursively(child); + } + } + file.delete(); + } +} diff --git a/quest-host/java/com/astrobotquest/vrhost/SandboxShell.java b/quest-host/java/com/astrobotquest/vrhost/SandboxShell.java new file mode 100644 index 0000000..f543de3 --- /dev/null +++ b/quest-host/java/com/astrobotquest/vrhost/SandboxShell.java @@ -0,0 +1,295 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +package com.astrobotquest.vrhost; + +import android.app.Activity; +import android.app.Application; +import android.app.Instrumentation; +import android.content.ComponentName; +import android.content.Intent; +import android.content.pm.ActivityInfo; +import android.os.Bundle; +import android.os.SystemClock; +import android.util.Log; +import android.view.InputDevice; +import android.view.KeyEvent; +import android.view.MotionEvent; + +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.InputStream; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.util.ArrayList; +import java.util.List; + +/** + * Development aid: runs things inside the app's sandbox without any activity, which means + * without anybody wearing (and unlocking) the headset. + * + * "adb shell" and "run-as" are not what the emulator core meets when the app starts it: they run + * under different SELinux domains (on Quest neither may allocate GPU memory) and without the + * system-call filter apps get. This runs as a real app process instead. + * + * A shell command, in the app's files folder; the tail of its output comes back as the result: + * + * adb shell am instrument -w -e cmd "<command>" com.astrobotquest.vrhost/.SandboxShell + * + * The host's own code path, minus the headset session: the core is started the way the app + * starts it, gets a controller and a moving head over the app's sockets, renders into the app's + * shared frame buffers, and what arrives there is saved as pictures in files/selftest: + * + * adb shell am instrument -w -e selftest <seconds> [-e game <eboot.bin>] [-e env "A=1 B=2"] \ + * [-e mic test|real|off] [-e install 1] com.astrobotquest.vrhost/.SandboxShell + * + * The game's microphone hears a test signal there (a second of noise every five), unless "mic" + * says to open the headset's own or none. + * + * The app's own start, without showing anything: the activity is created and its onCreate runs + * as it does when the app is launched (settings, OpenXR, runtime, emulator, status panel), for + * the given seconds; then it is destroyed. What comes back is the host.log it wrote: + * + * adb shell am instrument -w -e drystart <seconds> [-e settings <file like vrhost.txt>] \ + * com.astrobotquest.vrhost/.SandboxShell + * + * What the headset's OpenXR runtime says of itself without a session ("1": that the app finds + * it and which of the extensions the host uses it has; "2": also what an instance tells, should + * the runtime let one be made without an activity; "3": the host itself, for the five seconds + * it takes to set up everything that comes before a session). The log is files/xrprobe.log: + * + * adb shell am instrument -w -e xrprobe 1 com.astrobotquest.vrhost/.SandboxShell + */ +public class SandboxShell extends Instrumentation { + private static final String TAG = "AstroVR"; + private static final int MAX_OUTPUT = 60 * 1024; + + private Bundle arguments; + + private static native String nativeSelfTest(String loader, String runtimeRoot, + String storageRoot, String game, String logFile, String outDir, int seconds, + String[] extraEnv, String microphone); + + private static native String nativeXrProbe(Object context, String logFile, int level); + + @Override + public void onCreate(Bundle arguments) { + super.onCreate(arguments); + this.arguments = arguments; + start(); + } + + @Override + public void onStart() { + Bundle result = new Bundle(); + try { + String selfTest = arguments.getString("selftest"); + String xrProbe = arguments.getString("xrprobe"); + String dryStart = arguments.getString("drystart"); + String report; + if (dryStart != null) { + report = runDryStart(Integer.parseInt(dryStart)); + } else if (xrProbe != null) { + System.loadLibrary("astrovr"); + report = nativeXrProbe(getTargetContext(), + new File(getTargetContext().getFilesDir(), "xrprobe.log") + .getAbsolutePath(), + Integer.parseInt(xrProbe)); + } else { + report = selfTest != null ? runSelfTest(Integer.parseInt(selfTest)) : runCommand(); + } + result.putString(REPORT_KEY_STREAMRESULT, report); + } catch (Throwable e) { + Log.e(TAG, "sandbox run failed", e); + result.putString(REPORT_KEY_STREAMRESULT, "failed: " + e + "\n"); + } + finish(Activity.RESULT_OK, result); + } + + /** + * Creates the app's activity the way the system does, short of giving it a window on a + * display, and lets it start everything it starts. + */ + private String runDryStart(int seconds) throws Exception { + // Where the activity leaves the pictures of its status panel, emptied of the last run's. + File pictures = new File(getTargetContext().getFilesDir(), "drystart"); + RuntimeInstaller.deleteRecursively(pictures); + pictures.mkdirs(); + // (An earlier version of this test put them next to the logs.) + for (int number = 0; number < 8; ++number) { + new File(getTargetContext().getExternalFilesDir(null), "status-" + number + ".png") + .delete(); + } + + final Intent intent = new Intent(getTargetContext(), MainActivity.class); + intent.putExtra("dry_run", true); + if (arguments.getString("settings") != null) { + intent.putExtra("settings", arguments.getString("settings")); + } + final ActivityInfo info = getTargetContext().getPackageManager().getActivityInfo( + new ComponentName(getTargetContext(), MainActivity.class), 0); + final Activity[] activity = new Activity[1]; + final Throwable[] failure = new Throwable[1]; + runOnMainSync(() -> { + try { + activity[0] = newActivity(MainActivity.class, getTargetContext(), null, + (Application) getTargetContext().getApplicationContext(), intent, info, + "Astro VR Host", null, null, null); + callActivityOnCreate(activity[0], null); + } catch (Throwable e) { + failure[0] = e; + } + }); + StringBuilder report = new StringBuilder(); + if (failure[0] != null) { + Log.e(TAG, "dry start failed", failure[0]); + report.append("the activity failed to start: ").append(Log.getStackTraceString(failure[0])) + .append('\n'); + } else { + // A controller that is not there: the events a gamepad would cause are handed to + // the activity as the system hands them over. Cross for a quarter of every five + // seconds gets the game past its first screens, the stick is moved in between. + long end = System.currentTimeMillis() + seconds * 1000L; + for (int step = 0; System.currentTimeMillis() < end; ++step) { + Thread.sleep(250); + final int phase = step % 20; + // Once, OPTIONS held for a second and a half and then the PS button: both ask + // for the view to be reset. + final int reset = step == 104 ? KeyEvent.KEYCODE_BUTTON_START + : step == 110 ? -KeyEvent.KEYCODE_BUTTON_START + : step == 114 ? KeyEvent.KEYCODE_BUTTON_MODE + : step == 115 ? -KeyEvent.KEYCODE_BUTTON_MODE : 0; + if (reset == 0 && (step < 80 || (phase != 0 && phase != 1 && phase != 10))) { + continue; + } + runOnMainSync(() -> { + try { + if (reset != 0) { + activity[0].dispatchKeyEvent(new KeyEvent( + reset > 0 ? KeyEvent.ACTION_DOWN : KeyEvent.ACTION_UP, + Math.abs(reset))); + } else if (phase == 10) { + activity[0].dispatchGenericMotionEvent(stickEvent(0.5f, -0.25f)); + } else { + activity[0].dispatchKeyEvent(new KeyEvent( + phase == 0 ? KeyEvent.ACTION_DOWN : KeyEvent.ACTION_UP, + KeyEvent.KEYCODE_BUTTON_A)); + } + } catch (Throwable e) { + failure[0] = e; + } + }); + if (failure[0] != null) { + report.append("input failed: ").append(Log.getStackTraceString(failure[0])) + .append('\n'); + failure[0] = null; + break; + } + } + } + if (activity[0] != null) { + runOnMainSync(() -> { + try { + callActivityOnDestroy(activity[0]); + } catch (Throwable e) { + failure[0] = e; + } + }); + if (failure[0] != null) { + report.append("stopping failed: ").append(Log.getStackTraceString(failure[0])) + .append('\n'); + } + } + File log = new File(getTargetContext().getExternalFilesDir(null), "host.log"); + if (log.isFile()) { + report.append(new String(Files.readAllBytes(log.toPath()), StandardCharsets.UTF_8)); + } else { + report.append("no host.log was written\n"); + } + return report.toString(); + } + + /** What a gamepad reports when its left stick is moved. */ + private static MotionEvent stickEvent(float x, float y) { + MotionEvent.PointerProperties[] properties = {new MotionEvent.PointerProperties()}; + properties[0].id = 0; + MotionEvent.PointerCoords[] coords = {new MotionEvent.PointerCoords()}; + coords[0].setAxisValue(MotionEvent.AXIS_X, x); + coords[0].setAxisValue(MotionEvent.AXIS_Y, y); + long now = SystemClock.uptimeMillis(); + return MotionEvent.obtain(now, now, MotionEvent.ACTION_MOVE, 1, properties, coords, 0, 0, + 1.0f, 1.0f, 0, 0, InputDevice.SOURCE_JOYSTICK, 0); + } + + private String runCommand() throws Exception { + String command = arguments.getString("cmd", "id"); + File directory = getTargetContext().getFilesDir(); + directory.mkdirs(); + ProcessBuilder builder = new ProcessBuilder("/system/bin/sh", "-c", command); + builder.directory(directory); + builder.redirectErrorStream(true); + builder.environment().put("ASTRO_LIB_DIR", + getTargetContext().getApplicationInfo().nativeLibraryDir); + builder.environment().put("ASTRO_EXTERNAL_DIR", + String.valueOf(getTargetContext().getExternalFilesDir(null))); + Process process = builder.start(); + + // Keep the end of the output, that is where failures are. + ByteArrayOutputStream output = new ByteArrayOutputStream(); + byte[] buffer = new byte[4096]; + try (InputStream in = process.getInputStream()) { + for (int count = in.read(buffer); count > 0; count = in.read(buffer)) { + output.write(buffer, 0, count); + if (output.size() > 2 * MAX_OUTPUT) { + byte[] all = output.toByteArray(); + output.reset(); + output.write(all, all.length - MAX_OUTPUT, MAX_OUTPUT); + } + } + } + int exit = process.waitFor(); + byte[] all = output.toByteArray(); + int from = Math.max(0, all.length - MAX_OUTPUT); + return new String(all, from, all.length - from, StandardCharsets.UTF_8) + + "\nexit=" + exit + "\n"; + } + + private String runSelfTest(int seconds) { + System.loadLibrary("astrovr"); + File files = getTargetContext().getFilesDir(); + File out = new File(files, "selftest"); + RuntimeInstaller.deleteRecursively(out); + out.mkdirs(); + File storage = new File(files, "selftest-core"); + storage.mkdirs(); + + // "install": the runtime comes out of the app's own assets first, as on the app's first + // start, instead of being whatever the test scripts last put there. + String installed = ""; + if (arguments.getString("install") != null) { + try { + File runtime = new File(files, "runtime"); + new File(runtime, ".stamp").delete(); + long begin = System.currentTimeMillis(); + RuntimeInstaller.install(getTargetContext(), runtime); + installed = "runtime unpacked from the app in " + + (System.currentTimeMillis() - begin) + " ms\n"; + } catch (java.io.IOException e) { + return "the runtime could not be unpacked: " + e + "\n"; + } + } + + List<String> env = new ArrayList<>(); + env.add("XDG_DATA_HOME=" + new File(out, "data")); + env.add("SHADPS4_MAX_MSAA=1"); + for (String entry : arguments.getString("env", "").split(" ")) { + if (!entry.isEmpty()) { + env.add(entry); + } + } + String game = arguments.getString("game", "/data/local/tmp/astro/games/CUSA12392/eboot.bin"); + return installed + nativeSelfTest( + getTargetContext().getApplicationInfo().nativeLibraryDir + "/libastro_ld.so", + new File(files, "runtime").getAbsolutePath(), storage.getAbsolutePath(), game, + new File(out, "core.log").getAbsolutePath(), out.getAbsolutePath(), seconds, + env.toArray(new String[0]), arguments.getString("mic", "test")); + } +} diff --git a/quest-host/res/values/strings.xml b/quest-host/res/values/strings.xml new file mode 100644 index 0000000..ec9d3d6 --- /dev/null +++ b/quest-host/res/values/strings.xml @@ -0,0 +1,4 @@ +<?xml version="1.0" encoding="utf-8"?> +<resources> + <string name="app_name">Astro VR Host</string> +</resources> diff --git a/quest-host/runtime/kgsl_compat.c b/quest-host/runtime/kgsl_compat.c new file mode 100644 index 0000000..bc5e6c1 --- /dev/null +++ b/quest-host/runtime/kgsl_compat.c @@ -0,0 +1,625 @@ +// SPDX-License-Identifier: MIT +// +// Lets Mesa's Turnip driver talk to the Adreno kernel driver (KGSL) on Meta Quest. +// +// Horizon OS filters KGSL ioctls by number for applications and only lets through the ones its +// own graphics driver uses, the "GPUOBJ" generation of the interface. Turnip still issues a few +// calls of the generation before, which are answered with EACCES there: +// +// IOCTL_KGSL_GPUMEM_ALLOC_ID allocate a buffer +// IOCTL_KGSL_GPUMEM_FREE_ID free it +// IOCTL_KGSL_GPUMEM_GET_INFO describe it +// IOCTL_KGSL_GPUMEM_SYNC_CACHE(_BULK) flush CPU caches for it +// IOCTL_KGSL_CMDSTREAM_READTIMESTAMP_CTXTID ask how far a context has got +// +// This library is preloaded into the emulator process (the glibc loader's --preload) and stands +// in front of libc's ioctl(): those calls are carried out with what is permitted, everything else +// goes to the kernel untouched. + +#define _GNU_SOURCE +#include <errno.h> +#include <pthread.h> +#include <stdarg.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/ioctl.h> +#include <sys/mman.h> +#include <sys/syscall.h> +#include <time.h> +#include <unistd.h> + +#define KGSL_IOC_TYPE 0x09 + +// --- the calls that are refused ---------------------------------------------------------------- + +struct kgsl_gpumem_alloc_id { + unsigned int id; + unsigned int flags; + size_t size; + size_t mmapsize; + unsigned long gpuaddr; + unsigned long pad[2]; +}; + +struct kgsl_gpumem_free_id { + unsigned int id; + unsigned int pad; +}; + +struct kgsl_gpumem_get_info { + unsigned long gpuaddr; + unsigned int id; + unsigned int flags; + size_t size; + size_t mmapsize; + unsigned long useraddr; + unsigned long pad[4]; +}; + +struct kgsl_gpumem_sync_cache { + unsigned long gpuaddr; + unsigned int id; + unsigned int op; + size_t offset; + size_t length; +}; + +struct kgsl_gpumem_sync_cache_bulk { + unsigned int* id_list; + unsigned int count; + unsigned int op; + unsigned int pad[2]; +}; + +struct kgsl_cmdstream_readtimestamp_ctxtid { + unsigned int context_id; + unsigned int type; + unsigned int timestamp; +}; + +enum { + NR_WAITTIMESTAMP_CTXTID = 0x07, + NR_DRAWCTXT_CREATE = 0x13, + NR_READTIMESTAMP_CTXTID = 0x16, + NR_TIMESTAMP_EVENT = 0x33, + NR_GPUMEM_ALLOC_ID = 0x34, + NR_GPUMEM_FREE_ID = 0x35, + NR_GPUMEM_GET_INFO = 0x36, + NR_GPUMEM_SYNC_CACHE = 0x37, + NR_GPUMEM_SYNC_CACHE_BULK = 0x3c, + NR_GPU_COMMAND = 0x4a, + NR_GPU_AUX_COMMAND = 0x57, +}; + +// --- the calls that are permitted -------------------------------------------------------------- + +struct kgsl_device_waittimestamp_ctxtid { + unsigned int context_id; + unsigned int timestamp; + unsigned int timeout; +}; +#define IOCTL_KGSL_DEVICE_WAITTIMESTAMP_CTXTID \ + _IOW(KGSL_IOC_TYPE, 0x7, struct kgsl_device_waittimestamp_ctxtid) + +struct kgsl_gpuobj_alloc { + uint64_t size; + uint64_t flags; + uint64_t va_len; + uint64_t mmapsize; + unsigned int id; + unsigned int metadata_len; + uint64_t metadata; +}; +#define IOCTL_KGSL_GPUOBJ_ALLOC _IOWR(KGSL_IOC_TYPE, 0x45, struct kgsl_gpuobj_alloc) + +struct kgsl_gpuobj_free { + uint64_t flags; + uint64_t priv; + unsigned int id; + unsigned int type; + unsigned int len; +}; +#define IOCTL_KGSL_GPUOBJ_FREE _IOW(KGSL_IOC_TYPE, 0x46, struct kgsl_gpuobj_free) + +struct kgsl_gpuobj_info { + uint64_t gpuaddr; + uint64_t flags; + uint64_t size; + uint64_t va_len; + uint64_t va_addr; + unsigned int id; +}; +#define IOCTL_KGSL_GPUOBJ_INFO _IOWR(KGSL_IOC_TYPE, 0x47, struct kgsl_gpuobj_info) + +struct kgsl_gpuobj_sync_obj { + uint64_t offset; + uint64_t length; + unsigned int id; + unsigned int op; +}; + +struct kgsl_gpuobj_sync { + uint64_t objs; + unsigned int obj_len; + unsigned int count; +}; +#define IOCTL_KGSL_GPUOBJ_SYNC _IOW(KGSL_IOC_TYPE, 0x49, struct kgsl_gpuobj_sync) + +/// The parts of the two submit calls that are of interest here: they share this tail. +struct kgsl_gpu_command { + uint64_t flags; + uint64_t cmdlist; + unsigned int cmdsize; + unsigned int numcmds; + uint64_t objlist; + unsigned int objsize; + unsigned int numobjs; + uint64_t synclist; + unsigned int syncsize; + unsigned int numsyncs; + unsigned int context_id; + unsigned int timestamp; +}; + +struct kgsl_gpu_aux_command { + uint64_t flags; + uint64_t cmdlist; + unsigned int cmdsize; + unsigned int numcmds; + uint64_t synclist; + unsigned int syncsize; + unsigned int numsyncs; + unsigned int context_id; + unsigned int timestamp; +}; + +static int kernel_ioctl(int fd, unsigned long request, void* arg) { + return (int)syscall(SYS_ioctl, fd, request, arg); +} + +static int tracing(void); +static void trace(const char* format, ...); + +// --- buffers ----------------------------------------------------------------------------------- + +static size_t g_allocated; + +static int gpumem_alloc_id(int fd, struct kgsl_gpumem_alloc_id* legacy) { + struct kgsl_gpuobj_alloc alloc; + memset(&alloc, 0, sizeof(alloc)); + alloc.size = legacy->size; + alloc.flags = legacy->flags; + if (kernel_ioctl(fd, IOCTL_KGSL_GPUOBJ_ALLOC, &alloc) != 0) { + return -1; + } + + // The old call also reported where the buffer sits in the GPU's address space. + struct kgsl_gpuobj_info info; + memset(&info, 0, sizeof(info)); + info.id = alloc.id; + if (kernel_ioctl(fd, IOCTL_KGSL_GPUOBJ_INFO, &info) != 0) { + const int error = errno; + struct kgsl_gpuobj_free release; + memset(&release, 0, sizeof(release)); + release.id = alloc.id; + kernel_ioctl(fd, IOCTL_KGSL_GPUOBJ_FREE, &release); + errno = error; + return -1; + } + + legacy->id = alloc.id; + legacy->flags = (unsigned int)info.flags; + legacy->size = info.size; + legacy->mmapsize = alloc.mmapsize; + legacy->gpuaddr = info.gpuaddr; + + // GPU memory is ordinary memory here, backed by pages from the moment it is allocated, and + // a headset has little of it to spare: with tracing on, the large allocations are listed. + const size_t total = __atomic_add_fetch(&g_allocated, info.size, __ATOMIC_RELAXED); + if (tracing() && info.size >= (8u << 20)) { + trace("allocated %zu MB of GPU memory, %zu MB in all", (size_t)info.size >> 20, + total >> 20); + } + return 0; +} + +static int gpumem_free_id(int fd, const struct kgsl_gpumem_free_id* legacy) { + struct kgsl_gpuobj_free release; + memset(&release, 0, sizeof(release)); + release.id = legacy->id; + return kernel_ioctl(fd, IOCTL_KGSL_GPUOBJ_FREE, &release); +} + +static int gpumem_get_info(int fd, struct kgsl_gpumem_get_info* legacy) { + if (legacy->id == 0) { + // Looking a buffer up by address has no successor. + errno = EINVAL; + return -1; + } + struct kgsl_gpuobj_info info; + memset(&info, 0, sizeof(info)); + info.id = legacy->id; + if (kernel_ioctl(fd, IOCTL_KGSL_GPUOBJ_INFO, &info) != 0) { + return -1; + } + legacy->gpuaddr = info.gpuaddr; + legacy->flags = (unsigned int)info.flags; + legacy->size = info.size; + legacy->mmapsize = info.va_len != 0 ? info.va_len : info.size; + legacy->useraddr = info.va_addr; + return 0; +} + +static int gpumem_sync_cache(int fd, const struct kgsl_gpumem_sync_cache* legacy) { + struct kgsl_gpuobj_sync_obj object; + memset(&object, 0, sizeof(object)); + object.offset = legacy->offset; + object.length = legacy->length; + object.id = legacy->id; + object.op = legacy->op; + struct kgsl_gpuobj_sync sync; + memset(&sync, 0, sizeof(sync)); + sync.objs = (uintptr_t)&object; + sync.obj_len = sizeof(object); + sync.count = 1; + return kernel_ioctl(fd, IOCTL_KGSL_GPUOBJ_SYNC, &sync); +} + +static int gpumem_sync_cache_bulk(int fd, const struct kgsl_gpumem_sync_cache_bulk* legacy) { + if (legacy->count == 0) { + return 0; + } + struct kgsl_gpuobj_sync_obj* objects = calloc(legacy->count, sizeof(*objects)); + if (objects == NULL) { + errno = ENOMEM; + return -1; + } + for (unsigned int i = 0; i < legacy->count; ++i) { + // Without the "range" bit in op the whole buffer is meant. + objects[i].id = legacy->id_list[i]; + objects[i].op = legacy->op; + } + struct kgsl_gpuobj_sync sync; + memset(&sync, 0, sizeof(sync)); + sync.objs = (uintptr_t)objects; + sync.obj_len = sizeof(*objects); + sync.count = legacy->count; + const int result = kernel_ioctl(fd, IOCTL_KGSL_GPUOBJ_SYNC, &sync); + const int error = errno; + free(objects); + errno = error; + return result; +} + +// --- timestamps -------------------------------------------------------------------------------- +// +// The call that reads how far a context has got is refused. The kernel also publishes those +// counters in a page any process may map read-only though, the "memstore", which is how +// Qualcomm's own driver follows them, and reading that costs no system call at all. +// +// Should the page not be available, the timestamps handed out on submission are noted and "the +// last retired one" is found by asking, one by one, whether they have been reached. That call +// can only wait: a timeout of zero means forever, so the shortest real one is used, and Turnip, +// which asks on every submission, then spends its time waiting for the GPU. + +struct kgsl_shadowprop { + unsigned long gpuaddr; + size_t size; + unsigned int flags; +}; + +struct kgsl_device_getproperty { + unsigned int type; + void* value; + size_t sizebytes; +}; +#define KGSL_PROP_DEVICE_SHADOW 0x2 +#define IOCTL_KGSL_DEVICE_GETPROPERTY _IOWR(KGSL_IOC_TYPE, 0x2, struct kgsl_device_getproperty) + +/// One entry per context id. +struct kgsl_devmemstore { + volatile unsigned int soptimestamp; // last command batch started + unsigned int sbz; + volatile unsigned int eoptimestamp; // last command batch finished + unsigned int sbz2; + volatile unsigned int preempted; + unsigned int sbz3; + volatile unsigned int ref_wait_ts; + unsigned int sbz4; + unsigned int current_context; + unsigned int sbz5; +}; + +#define KGSL_TIMESTAMP_CONSUMED 1 +#define KGSL_TIMESTAMP_RETIRED 2 + +#define MAX_CONTEXTS 16 +#define MAX_PENDING 256 + +struct context_state { + unsigned int id; + int used; + unsigned int newest; // last timestamp handed out + unsigned int retired; // last timestamp known to be done + unsigned int pending[MAX_PENDING]; // submitted and not yet seen done, oldest first + unsigned int count; +}; + +static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER; +static struct context_state g_contexts[MAX_CONTEXTS]; +static const struct kgsl_devmemstore* g_memstore; +static size_t g_memstore_entries; +static int g_memstore_tried; + +/// Called with the lock held. +static void map_memstore(int fd) { + g_memstore_tried = 1; + struct kgsl_shadowprop shadow; + memset(&shadow, 0, sizeof(shadow)); + struct kgsl_device_getproperty property; + memset(&property, 0, sizeof(property)); + property.type = KGSL_PROP_DEVICE_SHADOW; + property.value = &shadow; + property.sizebytes = sizeof(shadow); + if (kernel_ioctl(fd, IOCTL_KGSL_DEVICE_GETPROPERTY, &property) != 0 || shadow.size == 0) { + fprintf(stderr, "kgsl_compat: no timestamp page (%s), GPU waits will be slow\n", + strerror(errno)); + return; + } + // The kernel recognises the mapping by its offset and insists on read-only and the full size. + void* mapping = mmap(NULL, shadow.size, PROT_READ, MAP_SHARED, fd, (off_t)shadow.gpuaddr); + if (mapping == MAP_FAILED) { + fprintf(stderr, + "kgsl_compat: cannot map the timestamp page (%s), GPU waits will be slow\n", + strerror(errno)); + return; + } + g_memstore = mapping; + g_memstore_entries = shadow.size / sizeof(struct kgsl_devmemstore); + fprintf(stderr, "kgsl_compat: reading timestamps from the kernel page, %zu contexts\n", + g_memstore_entries); +} + +static struct context_state* find_context(unsigned int id) { + struct context_state* unused = NULL; + for (int i = 0; i < MAX_CONTEXTS; ++i) { + if (g_contexts[i].used && g_contexts[i].id == id) { + return &g_contexts[i]; + } + if (!g_contexts[i].used && unused == NULL) { + unused = &g_contexts[i]; + } + } + if (unused == NULL) { + // Contexts come and go rarely; recycle the first slot rather than fail. + unused = &g_contexts[0]; + } + memset(unused, 0, sizeof(*unused)); + unused->used = 1; + unused->id = id; + return unused; +} + +static void note_submission(unsigned int context_id, unsigned int timestamp) { + pthread_mutex_lock(&g_lock); + struct context_state* context = find_context(context_id); + context->newest = timestamp; + if (g_memstore == NULL) { + if (context->count == MAX_PENDING) { + // Nobody asked for a long time. The oldest half is done for sure by now. + context->retired = context->pending[MAX_PENDING / 2 - 1]; + memmove(context->pending, context->pending + MAX_PENDING / 2, + sizeof(context->pending[0]) * (MAX_PENDING / 2)); + context->count = MAX_PENDING / 2; + } + context->pending[context->count++] = timestamp; + } + pthread_mutex_unlock(&g_lock); +} + +static int is_retired(int fd, unsigned int context_id, unsigned int timestamp) { + struct kgsl_device_waittimestamp_ctxtid wait; + wait.context_id = context_id; + wait.timestamp = timestamp; + wait.timeout = 1; + return kernel_ioctl(fd, IOCTL_KGSL_DEVICE_WAITTIMESTAMP_CTXTID, &wait) == 0; +} + +static int read_timestamp(int fd, struct kgsl_cmdstream_readtimestamp_ctxtid* request) { + const int saved_errno = errno; + pthread_mutex_lock(&g_lock); + if (!g_memstore_tried) { + map_memstore(fd); + } + struct context_state* context = find_context(request->context_id); + if (request->type != KGSL_TIMESTAMP_CONSUMED && request->type != KGSL_TIMESTAMP_RETIRED) { + // Queued: the newest one handed out. + request->timestamp = context->newest; + } else if (g_memstore != NULL && request->context_id < g_memstore_entries) { + const struct kgsl_devmemstore* entry = &g_memstore[request->context_id]; + request->timestamp = request->type == KGSL_TIMESTAMP_RETIRED ? entry->eoptimestamp + : entry->soptimestamp; + } else { + // Submissions retire in order: drop every leading one that is done. + unsigned int done = 0; + while (done < context->count && + is_retired(fd, request->context_id, context->pending[done])) { + context->retired = context->pending[done]; + ++done; + } + if (done > 0) { + memmove(context->pending, context->pending + done, + sizeof(context->pending[0]) * (context->count - done)); + context->count -= done; + } + request->timestamp = context->retired; + } + pthread_mutex_unlock(&g_lock); + errno = saved_errno; + return 0; +} + +// --- priority ---------------------------------------------------------------------------------- +// +// The GPU works through the commands of several programs: here the emulator's, the host app's +// (which copies each finished picture to where the headset's compositor takes it from) and the +// compositor's. The kernel driver keeps one queue per priority level and lets a higher one +// interrupt a lower one. Turnip asks for no priority, which makes the emulator the equal of the +// host app: the app's small copy then waits behind everything the emulator has queued up, tens +// of milliseconds when the game is busy, and a picture that is ready is not shown. +// +// KGSL_COMPAT_PRIORITY=<n> gives the emulator's GPU contexts priority n instead: 0 is the +// highest, 8 what a context gets when it asks for nothing, 12 to 15 the lowest level. Should the +// kernel refuse, the context is created the way the driver asked for it. + +struct kgsl_drawctxt_create { + unsigned int flags; + unsigned int drawctxt_id; +}; + +#define KGSL_CONTEXT_PRIORITY_MASK 0x0000f000u +#define KGSL_CONTEXT_PRIORITY_SHIFT 12 + +static int create_context(int fd, unsigned long request, struct kgsl_drawctxt_create* create) { + const unsigned int asked = create->flags; + const char* setting = getenv("KGSL_COMPAT_PRIORITY"); + const int priority = setting != NULL && setting[0] != '\0' ? atoi(setting) : -1; + if (priority >= 0 && priority <= 15) { + create->flags = (asked & ~KGSL_CONTEXT_PRIORITY_MASK) | + ((unsigned int)priority << KGSL_CONTEXT_PRIORITY_SHIFT); + } + int result = kernel_ioctl(fd, request, create); + if (result != 0 && create->flags != asked) { + const int error = errno; + create->flags = asked; + result = kernel_ioctl(fd, request, create); + fprintf(stderr, "kgsl_compat: priority %d refused (%s), context created as asked\n", + priority, strerror(error)); + } + if (result == 0) { + // The kernel writes back what the context got. + fprintf(stderr, "kgsl_compat: GPU context %u, priority %u (flags 0x%x, asked 0x%x)\n", + create->drawctxt_id, + (create->flags & KGSL_CONTEXT_PRIORITY_MASK) >> KGSL_CONTEXT_PRIORITY_SHIFT, + create->flags, asked); + } + return result; +} + +// --- tracing ----------------------------------------------------------------------------------- +// +// KGSL_COMPAT_TRACE=1 in the environment logs every submission and every timestamp call to +// stderr, with the calling thread and a millisecond clock: enough to see why a fence does not +// signal or what a thread is waiting for. + +struct kgsl_timestamp_event { + int type; + unsigned int timestamp; + unsigned int context_id; + void* priv; + size_t len; +}; + +static int tracing(void) { + static int enabled = -1; + if (enabled < 0) { + enabled = getenv("KGSL_COMPAT_TRACE") != NULL; + } + return enabled; +} + +static void trace(const char* format, ...) { + const int saved_errno = errno; + struct timespec now; + clock_gettime(CLOCK_MONOTONIC, &now); + char line[256]; + va_list arguments; + va_start(arguments, format); + vsnprintf(line, sizeof(line), format, arguments); + va_end(arguments); + fprintf(stderr, "kgsl %ld.%03ld [%ld] %s\n", (long)(now.tv_sec % 1000), + now.tv_nsec / 1000000, (long)syscall(SYS_gettid), line); + errno = saved_errno; +} + +// --- entry point ------------------------------------------------------------------------------- + +int ioctl(int fd, unsigned long request, ...) { + va_list arguments; + va_start(arguments, request); + void* arg = va_arg(arguments, void*); + va_end(arguments); + + if (_IOC_TYPE(request) != KGSL_IOC_TYPE || arg == NULL) { + return kernel_ioctl(fd, request, arg); + } + + switch (_IOC_NR(request)) { + case NR_DRAWCTXT_CREATE: + return create_context(fd, request, arg); + case NR_GPUMEM_ALLOC_ID: + return gpumem_alloc_id(fd, arg); + case NR_GPUMEM_FREE_ID: + return gpumem_free_id(fd, arg); + case NR_GPUMEM_GET_INFO: + return gpumem_get_info(fd, arg); + case NR_GPUMEM_SYNC_CACHE: + return gpumem_sync_cache(fd, arg); + case NR_GPUMEM_SYNC_CACHE_BULK: + return gpumem_sync_cache_bulk(fd, arg); + case NR_READTIMESTAMP_CTXTID: { + const int result = read_timestamp(fd, arg); + if (tracing()) { + const struct kgsl_cmdstream_readtimestamp_ctxtid* read = arg; + trace("read context %u type %u -> %u", read->context_id, read->type, + read->timestamp); + } + return result; + } + case NR_WAITTIMESTAMP_CTXTID: { + const struct kgsl_device_waittimestamp_ctxtid* wait = arg; + const unsigned int timestamp = wait->timestamp; + const unsigned int timeout = wait->timeout; + const int result = kernel_ioctl(fd, request, arg); + if (tracing()) { + trace("wait context %u for %u, timeout %u -> %d%s%s", wait->context_id, timestamp, + timeout, result, result != 0 ? " " : "", result != 0 ? strerror(errno) : ""); + } + return result; + } + case NR_TIMESTAMP_EVENT: { + const int result = kernel_ioctl(fd, request, arg); + if (tracing()) { + const struct kgsl_timestamp_event* event = arg; + trace("fence for context %u timestamp %u -> %d", event->context_id, + event->timestamp, result); + } + return result; + } + case NR_GPU_COMMAND: { + const int result = kernel_ioctl(fd, request, arg); + const struct kgsl_gpu_command* command = arg; + if (result == 0) { + note_submission(command->context_id, command->timestamp); + } + if (tracing()) { + trace("submit context %u, %u commands, %u sync points -> %d timestamp %u%s%s", + command->context_id, command->numcmds, command->numsyncs, result, + command->timestamp, result != 0 ? " " : "", result != 0 ? strerror(errno) : ""); + } + return result; + } + case NR_GPU_AUX_COMMAND: { + const int result = kernel_ioctl(fd, request, arg); + if (result == 0) { + const struct kgsl_gpu_aux_command* command = arg; + note_submission(command->context_id, command->timestamp); + } + return result; + } + default: + return kernel_ioctl(fd, request, arg); + } +} diff --git a/shadps4-arm64-main/CMakeLists.txt b/shadps4-arm64-main/CMakeLists.txt index e56c54a..f8915af 100644 --- a/shadps4-arm64-main/CMakeLists.txt +++ b/shadps4-arm64-main/CMakeLists.txt @@ -42,6 +42,9 @@ option(ENABLE_TESTS "Build unit tests (requires GTest)" OFF) option(ENABLE_BACHATA_RUNTIME "Build x86-64 Android-container runtime mode" OFF) option(ENABLE_SYSTEM_LIBRARIES "Enable building against system libraries" OFF) option(ENABLE_FEX_GUEST_CPU "Build the native ARM64 FEXCore guest CPU backend" OFF) +# The headset of the machine the emulator runs on, through that machine's OpenXR runtime +# (Virtual Desktop, SteamVR, ...): where the frames of an emulated PlayStation VR are shown. +cmake_dependent_option(ENABLE_OPENXR "Show the emulated headset's frames in a headset of this machine" ON "WIN32;NOT ENABLE_BACHATA_RUNTIME" OFF) set(FEXCORE_GUEST_CPU_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/runtime/sources/fex" CACHE PATH "Checked-out FEX source directory for the FEXCore guest CPU backend") set(FEXCORE_GUEST_CPU_BUILD_DIR "${CMAKE_CURRENT_SOURCE_DIR}/runtime/build/fexcore-smoke-build" CACHE PATH @@ -76,6 +79,19 @@ if (ARCHITECTURE STREQUAL "x86_64") add_compile_options(-march=x86-64-v3) endif() +# Source paths end up in the binaries (__FILE__ in asserts and log lines): count them from the +# folder above this one, so that a build does not carry the folders of the machine it was made +# on, user names among them. +if (CMAKE_C_COMPILER_ID MATCHES "Clang" OR CMAKE_C_COMPILER_ID STREQUAL "GNU") + get_filename_component(SHADPS4_PATH_ROOT "${CMAKE_SOURCE_DIR}/.." ABSOLUTE) + if (MSVC) + set(SHADPS4_PREFIX_MAP "/clang:-ffile-prefix-map=${SHADPS4_PATH_ROOT}/=") + else() + set(SHADPS4_PREFIX_MAP "-ffile-prefix-map=${SHADPS4_PATH_ROOT}/=") + endif() + add_compile_options("$<$<COMPILE_LANGUAGE:C,CXX>:${SHADPS4_PREFIX_MAP}>") +endif() + if (ENABLE_FEX_GUEST_CPU) if (NOT ARCHITECTURE STREQUAL "arm64") message(FATAL_ERROR "ENABLE_FEX_GUEST_CPU requires an ARM64 shadPS4 host") @@ -329,6 +345,7 @@ set(AUDIO_LIB src/core/libraries/audio/audioin.cpp src/core/libraries/audio/audioin_backend.h src/core/libraries/audio/audioin_error.h src/core/libraries/audio/sdl_audio_in.cpp + src/core/libraries/audio/bachata_audio_in.cpp src/core/libraries/voice/voice.cpp src/core/libraries/voice/voice.h src/core/libraries/audio/audioout.cpp @@ -338,10 +355,14 @@ set(AUDIO_LIB src/core/libraries/audio/audioin.cpp src/core/libraries/audio/sdl_audio_out.cpp src/core/libraries/audio/openal_audio_out.cpp src/core/libraries/audio/bachata_audio_out.cpp + src/core/libraries/audio/surround_virtualizer.cpp + src/core/libraries/audio/surround_virtualizer.h src/core/libraries/audio/openal_manager.h src/core/libraries/ngs2/ngs2.cpp src/core/libraries/ngs2/ngs2.h src/core/libraries/audio3d/audio3d.cpp + src/core/libraries/audio3d/audio3d_spatializer.cpp + src/core/libraries/audio3d/audio3d_spatializer.h src/core/libraries/audio3d/audio3d_openal.cpp src/core/libraries/audio3d/audio3d_openal.h src/core/libraries/audio3d/audio3d.h @@ -499,6 +520,13 @@ set(SYSTEM_LIBS src/core/libraries/system/commondialog.cpp src/core/libraries/ngs2/ngs2.cpp src/core/libraries/ngs2/ngs2.h src/core/libraries/ngs2/ngs2_error.h + src/core/libraries/ngs2/ngs2_codec.cpp + src/core/libraries/ngs2/ngs2_codec.h + src/core/libraries/ngs2/ngs2_dsp.cpp + src/core/libraries/ngs2/ngs2_dsp.h + src/core/libraries/ngs2/ngs2_engine.cpp + src/core/libraries/ngs2/ngs2_engine.h + src/core/libraries/ngs2/ngs2_hevag_table.h src/core/libraries/ngs2/ngs2_impl.cpp src/core/libraries/ngs2/ngs2_impl.h src/core/libraries/ngs2/ngs2_custom.cpp @@ -523,6 +551,8 @@ set(SYSTEM_LIBS src/core/libraries/system/commondialog.cpp src/core/libraries/audio3d/audio3d.cpp src/core/libraries/audio3d/audio3d.h src/core/libraries/audio3d/audio3d_error.h + src/core/libraries/audio3d/audio3d_spatializer.cpp + src/core/libraries/audio3d/audio3d_spatializer.h src/core/libraries/game_live_streaming/gamelivestreaming.cpp src/core/libraries/game_live_streaming/gamelivestreaming.h src/core/libraries/remote_play/remoteplay.cpp @@ -634,6 +664,10 @@ set(PLAYGO_LIB src/core/libraries/playgo/playgo.cpp src/core/libraries/playgo/playgo_types.h ) +set(JSON_LIB src/core/libraries/json/json.cpp + src/core/libraries/json/json.h +) + set(RANDOM_LIB src/core/libraries/random/random.cpp src/core/libraries/random/random.h src/core/libraries/random/random_error.h @@ -651,11 +685,18 @@ set(USBD_LIB src/core/libraries/usbd/usbd.cpp src/core/libraries/usbd/emulated/skylander.h ) -set(FIBER_LIB src/core/libraries/fiber/fiber_context.s - src/core/libraries/fiber/fiber.cpp +set(FIBER_LIB src/core/libraries/fiber/fiber.cpp src/core/libraries/fiber/fiber.h src/core/libraries/fiber/fiber_error.h + src/core/libraries/fiber/fiber_internal.h ) +if (ARCHITECTURE STREQUAL "x86_64") + # Fibers switch with native context switches where the guest runs natively... + list(APPEND FIBER_LIB src/core/libraries/fiber/fiber_context.s) +else() + # ...and by swapping guest registers where it runs under FEX. + list(APPEND FIBER_LIB src/core/libraries/fiber/fiber_fex.cpp) +endif() set_source_files_properties(src/core/libraries/fiber/fiber_context.s PROPERTIES COMPILE_OPTIONS -Wno-unused-command-line-argument) @@ -731,9 +772,21 @@ set(VR_LIBS src/core/libraries/hmd/hmd.cpp src/core/libraries/hmd/hmd.h src/core/libraries/hmd/hmd_setup_dialog.cpp src/core/libraries/hmd/hmd_setup_dialog.h + src/core/libraries/social_screen/social_screen.cpp + src/core/libraries/social_screen/social_screen.h src/core/libraries/vr_tracker/vr_tracker.cpp src/core/libraries/vr_tracker/vr_tracker.h + src/core/vr/vr_host_link.cpp + src/core/vr/vr_host_link.h + src/core/vr/vr_protocol.h + src/core/vr/vr_runtime.cpp + src/core/vr/vr_runtime.h ) +if (ENABLE_OPENXR) + list(APPEND VR_LIBS src/core/vr/openxr_host.cpp + src/core/vr/openxr_host.h + ) +endif() set(MISC_LIBS src/core/libraries/screenshot/screenshot.cpp src/core/libraries/screenshot/screenshot.h @@ -851,6 +904,7 @@ set(COMMON src/common/logging/classes.h src/common/uint128.h src/common/unique_function.h src/common/va_ctx.h + src/common/wave_dump.h src/common/ntapi.h src/common/ntapi.cpp src/common/number_utils.h @@ -943,6 +997,7 @@ set(CORE src/core/aerolib/stubs.cpp ${JPEG_LIB} ${PLAYGO_LIB} ${RANDOM_LIB} + ${JSON_LIB} ${USBD_LIB} ${ZLIB_LIB} ${MISC_LIBS} @@ -958,6 +1013,10 @@ set(CORE src/core/aerolib/stubs.cpp src/core/debugger.h src/core/guest_cpu/guest_cpu.cpp src/core/guest_cpu/guest_cpu.h + src/core/guest_cpu/guest_watchdog.cpp + src/core/guest_cpu/guest_watchdog.h + src/core/known_title.cpp + src/core/known_title.h src/core/linker.cpp src/core/linker.h src/core/memory.cpp @@ -989,6 +1048,7 @@ if (ARCHITECTURE STREQUAL "x86_64") endif() if (ENABLE_FEX_GUEST_CPU) + list(APPEND CORE ${FIBER_LIB}) list(APPEND CORE src/core/fex/fex_guest_engine.cpp src/core/fex/fex_guest_engine.h @@ -1154,6 +1214,8 @@ set(VIDEO_CORE src/video_core/amdgpu/cb_db_extent.h src/video_core/renderer_vulkan/vk_pipeline_serialization.h src/video_core/renderer_vulkan/vk_platform.cpp src/video_core/renderer_vulkan/vk_platform.h + src/video_core/renderer_vulkan/vk_vr_exporter.cpp + src/video_core/renderer_vulkan/vk_vr_exporter.h src/video_core/renderer_vulkan/vk_presenter.cpp src/video_core/renderer_vulkan/vk_presenter.h src/video_core/renderer_vulkan/vk_rasterizer.cpp @@ -1237,6 +1299,8 @@ set(INPUT src/input/controller.cpp src/input/input_handler.h src/input/input_mouse.cpp src/input/input_mouse.h + src/input/scripted_input.cpp + src/input/scripted_input.h ) set(EMULATOR src/emulator.cpp @@ -1271,13 +1335,19 @@ add_executable(shadps4 if (ENABLE_BACHATA_RUNTIME) target_compile_definitions(shadps4 PRIVATE ENABLE_BACHATA_RUNTIME) - target_sources(shadps4 PRIVATE - src/platform/bachata/runtime_client.cpp - src/platform/bachata/controller_snapshot.cpp - src/platform/bachata/audio_transport.cpp - src/platform/bachata/runtime_client.h - ) endif() +if (ENABLE_OPENXR) + target_compile_definitions(shadps4 PRIVATE ENABLE_OPENXR_HOST) + target_link_libraries(shadps4 PRIVATE OpenXR::openxr_loader) +endif() +# Common code (video out, audio out) references the runtime client unconditionally, so the +# platform layer is always built; it degrades to a disabled client outside the Android runtime. +target_sources(shadps4 PRIVATE + src/platform/bachata/runtime_client.cpp + src/platform/bachata/controller_snapshot.cpp + src/platform/bachata/audio_transport.cpp + src/platform/bachata/runtime_client.h +) create_target_directory_groups(shadps4) @@ -1439,7 +1509,7 @@ if (WIN32) endif() endif() -if (WIN32) +if (WIN32 AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/dist/shadps4.rc") target_sources(shadps4 PRIVATE src/dist/shadps4.rc) endif() diff --git a/shadps4-arm64-main/externals/CMakeLists.txt b/shadps4-arm64-main/externals/CMakeLists.txt index be1848c..fdfb456 100644 --- a/shadps4-arm64-main/externals/CMakeLists.txt +++ b/shadps4-arm64-main/externals/CMakeLists.txt @@ -95,6 +95,16 @@ if (NOT TARGET GPUOpen::VulkanMemoryAllocator) add_subdirectory(vma) endif() +# OpenXR loader (Khronos OpenXR-SDK 1.1.63), to reach the headset of the machine itself +if (ENABLE_OPENXR AND NOT TARGET OpenXR::openxr_loader) + set(BUILD_TESTS OFF) + set(BUILD_API_LAYERS OFF) + set(BUILD_CONFORMANCE_TESTS OFF) + set(BUILD_SDK_TESTS OFF) + set(DYNAMIC_LOADER OFF) + add_subdirectory(openxr-sdk) +endif() + # RenderDoc if (NOT TARGET RenderDoc::API) add_library(renderdoc INTERFACE) diff --git a/shadps4-arm64-main/externals/openxr-sdk/.appveyor.yml b/shadps4-arm64-main/externals/openxr-sdk/.appveyor.yml new file mode 100644 index 0000000..711ecbc --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.appveyor.yml @@ -0,0 +1,53 @@ +# Copyright (c) 2017-2026 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 + +version: 1.1.63.{build} +image: Visual Studio 2017 + + +environment: + VULKAN_SDK: c:\VulkanSDK\1.1.114.0 + VKSDKURL: https://people.collabora.com/~rpavlik/ci_resources/vksdk-1.1.114.0-lite.7z + VKSDKPKG: c:\VulkanSDK\vksdk-1.1.114.0-lite.7z + matrix: +# 32-bit + - VCVARS: vcvarsamd64_x86 + VCPKG_PLATFORM: x86-windows +# 64-bit + - VCVARS: vcvars64 + VCPKG_PLATFORM: x64-windows + +matrix: + fast_finish: true # finish immediately once one of the jobs fails + +# fetch repository as zip archive +shallow_clone: true # default is "false" + + +cache: + - c:\VulkanSDK\1.1.114.0 +install: + - choco install -y ninja + # - ps: $blockRdp = $true; iex ((new-object net.webclient).DownloadString('https://raw.githubusercontent.com/appveyor/ci/master/scripts/enable-rdp.ps1')) + # Download and extract a stripped-down Vulkan SDK if not cached - the "Start-Process" is to not continue until extraction is done + - ps: >- + if (-not (Test-Path "$env:VULKAN_SDK/Include/vulkan/vulkan.h")) { + mkdir c:\VulkanSDK + $wc = New-Object System.Net.WebClient + $wc.DownloadFile($env:VKSDKURL, $env:VKSDKPKG) + Start-Process "c:\Program Files\7-Zip\7z" -ArgumentList "x", $env:VKSDKPKG, "-oC:\VulkanSDK" -Wait + } + +# for future use if we need vcpkg +# -DCMAKE_TOOLCHAIN_FILE=c:/tools/vcpkg/scripts/buildsystems/vcpkg.cmake + +build_script: +- cmd: >- + call "C:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\Community\\VC\\Auxiliary\\Build\\%VCVARS%.bat" && + cmake -GNinja -Bbuild -H. -DCMAKE_BUILD_TYPE=RelWithDebInfo -DPython3_EXECUTABLE=C:/Python37-x64/python.exe -DBUILD_ALL_EXTENSIONS=ON && + ninja -C build +- cmd: >- + call "C:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\Community\\VC\\Auxiliary\\Build\\%VCVARS%.bat" && + cmake -GNinja -Bbuild -H. -DCMAKE_BUILD_TYPE=RelWithDebInfo -DDYNAMIC_LOADER=ON -DPython3_EXECUTABLE=C:/Python37-x64/python.exe -DBUILD_ALL_EXTENSIONS=ON && + ninja -C build diff --git a/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/nuget/NugetTemplate/OpenXR.Loader.nuspec b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/nuget/NugetTemplate/OpenXR.Loader.nuspec new file mode 100644 index 0000000..6df65bf --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/nuget/NugetTemplate/OpenXR.Loader.nuspec @@ -0,0 +1,18 @@ +<?xml version="1.0" encoding="utf-8"?> +<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd"> + <!-- + Copyright (c) 2020-2026 The Khronos Group Inc. + SPDX-License-Identifier: CC-BY-4.0 + --> + <metadata> + <id>OpenXR.Loader</id> + <version></version> + <authors>Khronos Group</authors> + <owners>Khronos Group</owners> + <requireLicenseAcceptance>false</requireLicenseAcceptance> + <license type="expression">Apache-2.0 OR MIT</license> + <projectUrl>https://github.com/KhronosGroup/OpenXR-SDK</projectUrl> + <description>Khronos OpenXR loader and headers required to build a Win32 or UWP OpenXR application</description> + <tags>native khronos openxr loader</tags> + </metadata> +</package> diff --git a/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/nuget/NugetTemplate/build/native/OpenXR.Loader.props b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/nuget/NugetTemplate/build/native/OpenXR.Loader.props new file mode 100644 index 0000000..012b2e4 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/nuget/NugetTemplate/build/native/OpenXR.Loader.props @@ -0,0 +1,9 @@ +<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <!-- + Copyright (c) 2020-2026 The Khronos Group Inc. + SPDX-License-Identifier: CC-BY-4.0 + --> + <PropertyGroup> + <OpenXRPackageRoot>$(MSBuildThisFileDirectory)..\..\</OpenXRPackageRoot> + </PropertyGroup> +</Project> diff --git a/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/nuget/NugetTemplate/build/native/OpenXR.Loader.targets b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/nuget/NugetTemplate/build/native/OpenXR.Loader.targets new file mode 100644 index 0000000..59899d7 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/nuget/NugetTemplate/build/native/OpenXR.Loader.targets @@ -0,0 +1,43 @@ +<Project ToolsVersion="4.0" + xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <!-- + Copyright (c) 2020-2026 The Khronos Group Inc. + SPDX-License-Identifier: CC-BY-4.0 + --> + + <Choose> + <When Condition="'$(ApplicationType)|$(ApplicationTypeRevision)' == 'Windows Store|10.0'"> + <PropertyGroup> + <OpenXRLoaderBinaryRoot>$(OpenXRPackageRoot)native\$(Platform)_uwp\release</OpenXRLoaderBinaryRoot> + </PropertyGroup> + </When> + <Otherwise> + <PropertyGroup> + <OpenXRLoaderBinaryRoot>$(OpenXRPackageRoot)native\$(Platform)\release</OpenXRLoaderBinaryRoot> + </PropertyGroup> + </Otherwise> + </Choose> + + <ItemDefinitionGroup> + <ClCompile> + <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories);$(OpenXRPackageRoot)include</AdditionalIncludeDirectories> + </ClCompile> + <Link> + <AdditionalDependencies>%(AdditionalDependencies);$(OpenXRLoaderBinaryRoot)\lib\openxr_loader.lib</AdditionalDependencies> + </Link> + </ItemDefinitionGroup> + + <!-- Copy the OpenXR loader DLL to the output directory and include in packaging --> + <ItemGroup Condition="'$(OpenXRSkipLoaderCopy)'!='true'"> + <None Include="$(OpenXRLoaderBinaryRoot)\bin\openxr_loader.dll"> + <Link>%(Filename)%(Extension)</Link> + <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory> + <DeploymentContent>true</DeploymentContent> + </None> + </ItemGroup> + + <Target Name="EnsurePropsImported" BeforeTargets="PrepareForBuild"> + <Error Condition="'$(OpenXRPackageRoot)'==''" Text="OpenXRPackageRoot property missing. Project is malformed. Try removing and re-adding the NuGet reference." /> + </Target> + +</Project> diff --git a/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/nuget/stage_nuget.ps1 b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/nuget/stage_nuget.ps1 new file mode 100644 index 0000000..3898165 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/nuget/stage_nuget.ps1 @@ -0,0 +1,77 @@ +# Copyright (c) 2019-2026 The Khronos Group Inc. +# SPDX-License-Identifier: Apache-2.0 +param( + [Parameter(Mandatory = $true, HelpMessage = "Path to unzipped openxr_loader_windows OpenXR-SDK release asset")] + $SDKRelease, + [Parameter(Mandatory = $true, HelpMessage = "Path to specification Makefile. Needed to extract the version")] + $SpecMakefile, + [Parameter(Mandatory = $true, HelpMessage = "Path create staged nuget directory layout")] + $NugetStaging) + +$ErrorActionPreference = "Stop" + +if (-Not (Test-Path $SDKRelease)) { + Throw "SDK Release folder not found: $SDKRelease" +} +if (-Not (Test-Path $SpecMakefile)) { + Throw "Specification makefile not found: $SpecMakefile" +} + +$NugetTemplate = Join-Path $PSScriptRoot "NugetTemplate" + +if (Test-Path $NugetStaging) { + Remove-Item $NugetStaging -Recurse +} + +# +# Extract version from Specification makefile +# +$VersionMatch = Select-String -Path $SpecMakefile -Pattern "^SPECREVISION\s*=\s*(.+)" +$SDKVersion = $VersionMatch.Matches[0].Groups[1] + +# +# Start off using the NuGet template. +# +Write-Output "Copy-Item $NugetTemplate $NugetStaging -Recurse" +Copy-Item $NugetTemplate $NugetStaging -Recurse + +# +# Update the NuSpec +# +$NuSpecPath = Resolve-Path (Join-Path $NugetStaging "OpenXR.Loader.nuspec") +$xml = [xml](Get-Content $NuSpecPath) +$nsm = New-Object Xml.XmlNamespaceManager($xml.NameTable) +$nsm.AddNamespace("ng", "http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd") +$xml.SelectSingleNode("/ng:package/ng:metadata/ng:version", $nsm).InnerText = $SDKVersion +$xml.Save($NuSpecPath) + +# +# Copy in the headers from the SDK release. +# +Copy-Item (Join-Path $SDKRelease "include") (Join-Path $NugetStaging "include") -Recurse + +# +# Copy in the binaries from the SDK release. +# +function CopyLoader($Platform) { + $PlatformSDKPath = Join-Path $SDKRelease "$Platform" + if (Test-Path $PlatformSDKPath) { + $NuGetPlatformPath = Join-Path $NugetStaging "native/$Platform/release" + + $NugetLibPath = Join-Path $NuGetPlatformPath "lib" + New-Item $NugetLibPath -ItemType "directory" -Force + Copy-Item (Join-Path $PlatformSDKPath "lib/openxr_loader.lib") $NugetLibPath + + $NugetBinPath = Join-Path $NuGetPlatformPath "bin" + New-Item $NugetBinPath -ItemType "directory" -Force + Copy-Item (Join-Path $PlatformSDKPath "bin/openxr_loader.dll") $NugetBinPath + } +} + +# Currently there are no non-UWP ARM/ARM64 binaries available from the SDK release. +CopyLoader "x64" +CopyLoader "Win32" +CopyLoader "x64_uwp" +CopyLoader "Win32_uwp" +CopyLoader "arm64_uwp" +CopyLoader "arm_uwp" diff --git a/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/openxr-sdk.yml b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/openxr-sdk.yml new file mode 100644 index 0000000..2bfad14 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/openxr-sdk.yml @@ -0,0 +1,18 @@ +# Copyright (c) 2019-2026 The Khronos Group Inc. +# SPDX-License-Identifier: Apache-2.0 + +# Main azure-pipelines configuration for the OpenXR-SDK repo. + +trigger: + branches: + include: + - "*" +variables: + VULKAN_SDK_VERSION: "1.1.114.0" + +stages: + - stage: Build + jobs: + - template: shared/build_jobs.yml + parameters: + isSdkSourceRepo: false diff --git a/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/build_jobs.yml b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/build_jobs.yml new file mode 100644 index 0000000..bdfb284 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/build_jobs.yml @@ -0,0 +1,173 @@ +# Copyright (c) 2019-2026 The Khronos Group Inc. +# SPDX-License-Identifier: Apache-2.0 + +parameters: + - name: sourceDir + type: string + default: "$(System.DefaultWorkingDirectory)" + - name: isSdkSourceRepo + type: boolean + default: true + +jobs: + # Build the loader, API layers, and samples on Linux + - job: linux_build + displayName: "Linux" + strategy: + matrix: + xlib: + buildType: RelWithDebInfo + presentationBackend: xlib + xcb: + buildType: RelWithDebInfo + presentationBackend: xcb + wayland: + buildType: RelWithDebInfo + presentationBackend: wayland + pool: + vmImage: "ubuntu-latest" + container: khronosgroup/docker-images:openxr-sdk.20240924@sha256:5e6a6f5d72dc4a20d5c33f12550fdd9b6a1206e94d6cf1382e0697a5726c424c + + steps: + # First build as debug + - template: build_linux.yml + parameters: + sourceDir: ${{parameters.sourceDir}} + buildType: Debug + cmakeArgs: "-DPRESENTATION_BACKEND=$(PresentationBackend)" + + # Then build release + - template: build_linux.yml + parameters: + sourceDir: ${{parameters.sourceDir}} + buildType: RelWithDebInfo + cmakeArgs: "-DPRESENTATION_BACKEND=$(PresentationBackend)" + + # This job computes the product of the config dimensions + - job: generator + pool: + vmImage: "ubuntu-latest" + steps: + - task: PythonScript@0 + name: winmatrix + inputs: + scriptPath: $(System.DefaultWorkingDirectory)/.azure-pipelines/shared/generate_windows_matrix_build.py + # argument sets the variable name defined by python script + arguments: winbuild + pythonInterpreter: /usr/bin/python3 + + # Build the loader, API layers, and samples on Windows + - job: windows_build + dependsOn: generator + displayName: "Windows MSVC" + variables: + VULKAN_SDK: "$(System.DefaultWorkingDirectory)\\vulkan_sdk\\$(VULKAN_SDK_VERSION)" + pool: + vmImage: "windows-latest" + # Use the json emitted by the generator job to set up this matrix + strategy: + matrix: $[ dependencies.generator.outputs['winmatrix.winbuild'] ] + steps: + - template: build_msvc.yml + parameters: + sourceDir: ${{parameters.sourceDir}} + buildType: $(buildType) + generator: "$(generator)" + cmakeArgs: $(cmakeArgs) -DBUILD_ALL_EXTENSIONS=ON -DINSTALL_TO_ARCHITECTURE_PREFIXES=ON + useVulkan: "true" + + - task: PublishPipelineArtifact@1 + displayName: Publish loader + condition: and(succeeded(), eq(variables.buildType, 'RelWithDebInfo')) + inputs: + path: ${{parameters.sourceDir}}/install + artifact: $(artifactName) + + # Build the loader, API layers, and samples on Windows with MinGW + # - job: mingw_build + # displayName: 'Windows MinGW' + # variables: + # VULKAN_SDK: "$(System.DefaultWorkingDirectory)\\vulkan_sdk\\$(VULKAN_SDK_VERSION)" + # pool: + # vmImage: 'windows-latest' + # steps: + # - template: build_mingw.yml + # parameters: + # sourceDir: ${{parameters.sourceDir}} + # buildType: RelWithDebInfo + # cmakeArgs: -DBUILD_ALL_EXTENSIONS=ON + # useVulkan: 'true' + + - job: combine_artifacts + dependsOn: + - generator + - windows_build + condition: ${{ eq(parameters.isSdkSourceRepo, true) }} + displayName: "Organize artifacts" + pool: + vmImage: "windows-latest" + steps: + - download: current + patterns: "**/*.dll" + displayName: Download dynamic libraries + - download: current + patterns: "**/*.pdb" + displayName: Download dynamic library symbols + - download: current + patterns: "**/*.lib" + displayName: Download link import libraries + - download: current + patterns: "**/*.h" + displayName: Download headers + - download: current + patterns: "**/*.cmake" + displayName: Download CMake scripts + - download: current + patterns: "**/*.exe" + displayName: Download executables + - download: current + patterns: "**/*.json" + displayName: Download manifests + # Use the specified version of Python from the tool cache + - task: UsePythonVersion@0 + inputs: + versionSpec: "3.10" + - task: PythonScript@0 + displayName: Move artifact contents + inputs: + scriptPath: $(System.DefaultWorkingDirectory)/.azure-pipelines/shared/organize_windows_artifacts.py + arguments: $(Pipeline.Workspace) $(System.DefaultWorkingDirectory)/openxr_loader + - task: PublishPipelineArtifact@1 + displayName: Publish combined artifact + condition: succeeded() + inputs: + path: $(System.DefaultWorkingDirectory)/openxr_loader + artifact: openxr_loader_windows + + # NuGet stuff + # See: + # https://learn.microsoft.com/en-us/azure/devops/pipelines/tasks/tool/nuget?view=azure-devops + # https://learn.microsoft.com/en-us/azure/devops/pipelines/tasks/package/nuget?view=azure-devops + + - task: PowerShell@2 + displayName: Stage loader and headers for NuGet + inputs: + filePath: $(System.DefaultWorkingDirectory)/.azure-pipelines/nuget/stage_nuget.ps1 + arguments: $(System.DefaultWorkingDirectory)/openxr_loader ` + $(Build.SourcesDirectory)/specification/Makefile ` + $(System.DefaultWorkingDirectory)/openxr_loader_staging + - task: NuGetToolInstaller@1 + inputs: + versionSpec: ">=5.0.0" + - task: NuGetCommand@2 + displayName: Package for NuGet + inputs: + command: pack + packagesToPack: $(System.DefaultWorkingDirectory)/openxr_loader_staging/OpenXR.Loader.nuspec + packDestination: $(System.DefaultWorkingDirectory)/nuget + - task: PublishPipelineArtifact@1 + displayName: Publish NuGet Package + condition: succeeded() + inputs: + path: $(System.DefaultWorkingDirectory)/nuget + artifact: NuGet diff --git a/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/build_linux.yml b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/build_linux.yml new file mode 100644 index 0000000..55df176 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/build_linux.yml @@ -0,0 +1,28 @@ +# Copyright (c) 2019-2026 The Khronos Group Inc. +# SPDX-License-Identifier: Apache-2.0 + +parameters: + - name: buildType + type: string + default: "RelWithDebInfo" + - name: cmakeArgs + type: string + default: "" + - name: sourceDir + type: string + default: "$(Pipeline.Workspace)" + - name: buildDir + type: string + default: "$(Build.BinariesDirectory)" + +steps: + - script: "rm -rf ${{ parameters.buildDir }}" + displayName: "Clean up build directory" + + - script: "cmake -G Ninja -S . -B ${{ parameters.buildDir }} -DCMAKE_BUILD_TYPE=${{ parameters.buildType }} ${{ parameters.cmakeArgs }}" + workingDirectory: "${{ parameters.sourceDir }}" + displayName: "Generate build system" + + - script: "ninja -C ${{ parameters.buildDir }}" + workingDirectory: "${{ parameters.sourceDir }}" + displayName: "Compile" diff --git a/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/build_mingw.yml b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/build_mingw.yml new file mode 100644 index 0000000..7f4d564 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/build_mingw.yml @@ -0,0 +1,48 @@ +# Copyright (c) 2019-2026 The Khronos Group Inc. +# SPDX-License-Identifier: Apache-2.0 + +parameters: + - name: buildType + type: string + default: "Debug" + - name: cmakeArgs + type: string + default: "" + - name: sourceDir + type: string + default: "$(System.DefaultWorkingDirectory)" + # TODO should be boolean + - name: useVulkan + type: string + default: "true" + +steps: + - checkout: self + lfs: true + + # - script: choco install -y ninja + # displayName: 'Install Ninja' + + - script: mkdir $(System.DefaultWorkingDirectory)\\vulkan_sdk + displayName: "Make Vulkan SDK dir" + + - powershell: ./.azure-pipelines/shared/install_vulkan.ps1 + displayName: Install Vulkan SDK + workingDirectory: "${{ parameters.sourceDir }}" + condition: eq('${{ parameters.useVulkan}}', 'true') + + - script: mkdir build + displayName: "Create build directory" + workingDirectory: "${{ parameters.sourceDir }}" + + - script: | + set VULKAN_SDK=$(System.DefaultWorkingDirectory)\\vulkan_sdk\\$(VULKAN_SDK_VERSION) + cmake .. -G "MinGW Makefiles" ${{ parameters.cmakeArgs }} -DCMAKE_BUILD_TYPE=${{ parameters.buildType }} -DCMAKE_INSTALL_PREFIX=${{ parameters.sourceDir }}/install + displayName: "Generate build system" + workingDirectory: "${{ parameters.sourceDir }}/build" + + - script: mingw32-make -C build -j + displayName: Build all targets + + - script: mingw32-make -C build install + displayName: Install build diff --git a/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/build_msvc.yml b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/build_msvc.yml new file mode 100644 index 0000000..73e5f9e --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/build_msvc.yml @@ -0,0 +1,53 @@ +# Copyright (c) 2019-2026 The Khronos Group Inc. +# SPDX-License-Identifier: Apache-2.0 + +parameters: + - name: buildType + type: string + default: "Debug" + - name: generator + type: string + default: "Visual Studio 17 2022" + - name: cmakeArgs + type: string + default: "" + - name: sourceDir + type: string + default: "$(System.DefaultWorkingDirectory)" + # TODO should be boolean + - name: useVulkan + type: string + default: "true" + +steps: + - checkout: self + lfs: true + + - powershell: ./.azure-pipelines/shared/install_vulkan.ps1 + displayName: Install Vulkan SDK + workingDirectory: "${{ parameters.sourceDir }}" + condition: eq('${{ parameters.useVulkan}}', 'true') + + - script: mkdir build + displayName: "Create build directory" + workingDirectory: "${{ parameters.sourceDir }}" + + - script: | + set VULKAN_SDK=$(System.DefaultWorkingDirectory)\\vulkan_sdk\\$(VULKAN_SDK_VERSION) + cmake .. -G "${{ parameters.generator }}" ${{ parameters.cmakeArgs }} -DCMAKE_INSTALL_PREFIX=${{ parameters.sourceDir }}/install + displayName: "Generate build system" + workingDirectory: "${{ parameters.sourceDir }}/build" + + - task: MSBuild@1 + displayName: Build all targets + inputs: + solution: "${{ parameters.sourceDir }}/build/ALL_BUILD.vcxproj" + maximumCpuCount: true + configuration: ${{ parameters.buildType }} + + - task: MSBuild@1 + displayName: Install build + inputs: + solution: "${{ parameters.sourceDir }}/build/INSTALL.vcxproj" + maximumCpuCount: true + configuration: ${{ parameters.buildType }} diff --git a/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/check_clang_format.yml b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/check_clang_format.yml new file mode 100644 index 0000000..e086c82 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/check_clang_format.yml @@ -0,0 +1,29 @@ +# Copyright (c) 2019-2026 The Khronos Group Inc. +# SPDX-License-Identifier: Apache-2.0 + +jobs: + - job: check_clang_format + displayName: "clang-format" + pool: + vmImage: "ubuntu-latest" + container: khronosgroup/docker-images:openxr.20260415@sha256:800fd68bd1b16b426555158f4aa06b2ef1c150fba922d7a11361fc85f6ba0bcd + + steps: + - checkout: self + lfs: true + + - script: ./runClangFormat.sh + displayName: Run clang-format + + - script: git diff --patch --exit-code > clang-format.patch + displayName: Save changes as diff + + # In case of failure (clang-format changes needed) do these two things + - script: echo "The following files need clang-formatting:"; sed -n -e "s/^diff.* b\///p" clang-format.patch + condition: failed() + - task: PublishPipelineArtifact@1 + displayName: Publish diff + condition: failed() + inputs: + path: $(System.DefaultWorkingDirectory)/clang-format.patch + artifact: clang-format-changes diff --git a/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/check_file_format.yml b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/check_file_format.yml new file mode 100644 index 0000000..e0cc9bc --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/check_file_format.yml @@ -0,0 +1,23 @@ +# Copyright (c) 2020-2026 The Khronos Group Inc. +# SPDX-License-Identifier: Apache-2.0 +jobs: + - job: check_file_format + displayName: "Check file formatting" + pool: + vmImage: "ubuntu-latest" + container: khronosgroup/docker-images:openxr-sdk.20240924@sha256:5e6a6f5d72dc4a20d5c33f12550fdd9b6a1206e94d6cf1382e0697a5726c424c + + steps: + - script: ./file_format.sh + displayName: File formatting checks (file_format.sh) + + - script: git diff --patch --exit-code > file_format.patch + displayName: Save changes as diff + - script: echo "The following files need file formatting:"; sed -n -e "s/^diff.* b\///p" file_format.patch + condition: failed() + - task: PublishPipelineArtifact@1 + displayName: Publish diff + condition: failed() + inputs: + path: $(System.DefaultWorkingDirectory)/file_format.patch + artifact: file_format_changes diff --git a/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/codespell.yml b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/codespell.yml new file mode 100644 index 0000000..a7d4686 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/codespell.yml @@ -0,0 +1,16 @@ +# Copyright (c) 2019-2026 The Khronos Group Inc. +# SPDX-License-Identifier: Apache-2.0 + +jobs: + - job: check_codespell + displayName: "codespell" + pool: + vmImage: "ubuntu-latest" + container: khronosgroup/docker-images:openxr-sdk.20240924@sha256:5e6a6f5d72dc4a20d5c33f12550fdd9b6a1206e94d6cf1382e0697a5726c424c + + steps: + - checkout: self + lfs: true + + - script: ./checkCodespell + displayName: Run Codespell script diff --git a/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/generate_windows_matrix_build.py b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/generate_windows_matrix_build.py new file mode 100644 index 0000000..3ee2449 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/generate_windows_matrix_build.py @@ -0,0 +1,38 @@ +#!/usr/bin/env python3 +# Copyright (c) 2019-2026 The Khronos Group Inc. +# SPDX-License-Identifier: Apache-2.0 + +from itertools import product + +from shared import (PLATFORMS, TRUE_FALSE, VS_VERSION, make_win_artifact_name, + output_json) + +if __name__ == "__main__": + + configs = {} + for platform, debug, uwp in product(PLATFORMS, (False,), TRUE_FALSE): + # No need to support ARM/ARM64 except for UWP. + if not uwp and (platform.lower() == 'arm' or platform.lower() == 'arm64'): + continue + + label = [platform] + config = [] + generator = VS_VERSION + config.append('-A ' + platform) + config.append('-DDYNAMIC_LOADER=ON') + if debug: + label.append('debug') + if uwp: + label.append('UWP') + config.append('-DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION=10.0') + name = '_'.join(label) + configs[name] = { + 'generator': generator, + 'buildType': 'Debug' if debug else 'RelWithDebInfo', + 'cmakeArgs': ' '.join(config) + } + if not debug: + configs[name]['artifactName'] = make_win_artifact_name( + platform, uwp) + + output_json(configs) diff --git a/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/install_vulkan.ps1 b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/install_vulkan.ps1 new file mode 100644 index 0000000..0d80c13 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/install_vulkan.ps1 @@ -0,0 +1,30 @@ +# Copyright (c) 2019-2026 The Khronos Group Inc. +# SPDX-License-Identifier: Apache-2.0 + +if (-not $env:VULKAN_SDK_VERSION) { + $env:VULKAN_SDK_VERSION = "1.1.114.0" +} + +$SDK_VER = $env:VULKAN_SDK_VERSION + +if (-not (Test-Path env:VULKAN_SDK)) { + if ($env:SYSTEM_DEFAULTWORKINGDIRECTORY) { + $env:VULKAN_SDK = "$env:SYSTEM_DEFAULTWORKINGDIRECTORY\vulkan_sdk\$SDK_VER" + } else { + $env:VULKAN_SDK = "c:\VulkanSDK\$SDK_VER" + } +} +$parent = Split-Path -path $env:VULKAN_SDK +Write-Output "Trying for Vulkan SDK $SDK_VER" +$FN = "vksdk-$SDK_VER-lite.7z" +$URL = "https://people.collabora.com/~rpavlik/ci_resources/$FN" +if (-not (Test-Path "$env:VULKAN_SDK/Include/vulkan/vulkan.h")) { + Write-Output "Downloading $URL" + $wc = New-Object System.Net.WebClient + $wc.DownloadFile($URL, "$(pwd)\$FN") + + Write-Output "Extracting $FN in silent, blocking mode to $env:VULKAN_SDK" + Start-Process "c:\Program Files\7-Zip\7z" -ArgumentList "x", $FN, "-o$parent" -Wait +} else { + Write-Output "$env:VULKAN_SDK found and contains header" +} diff --git a/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/organize_windows_artifacts.py b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/organize_windows_artifacts.py new file mode 100644 index 0000000..a1d7343 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/organize_windows_artifacts.py @@ -0,0 +1,48 @@ +#!/usr/bin/env python3 +# Copyright (c) 2019-2026 The Khronos Group Inc. +# SPDX-License-Identifier: Apache-2.0 + +from itertools import product +from pathlib import Path +import shutil +import sys + +from shared import PLATFORMS, TRUE_FALSE, VS_VERSION, make_win_artifact_name + +CWD = Path.cwd() + + +def move(src, dest): + + print(str(src), '->', str(dest)) + src.replace(dest) + + +if __name__ == "__main__": + + configs = {} + workspace = Path(sys.argv[1]) + outbase = Path(sys.argv[2]) + + common_copied = False + + for platform, uwp in product(PLATFORMS, TRUE_FALSE): + # ARM/ARM64 is only built for the UWP platform. + if not uwp and (platform.lower() == 'arm' or platform.lower() == 'arm64'): + continue + + platform_dirname = '{}{}'.format(platform, + '_uwp' if uwp else '') + + name = make_win_artifact_name(platform, uwp) + + artifact = workspace / name + + if not common_copied: + # Start by copying the full tree over. + shutil.copytree(artifact, outbase, dirs_exist_ok=True) + common_copied = True + continue + + # lib files + shutil.copytree(artifact / platform_dirname, outbase / platform_dirname, dirs_exist_ok=True) diff --git a/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/print_windows_artifact_names.py b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/print_windows_artifact_names.py new file mode 100644 index 0000000..ceddaf4 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/print_windows_artifact_names.py @@ -0,0 +1,12 @@ +#!/usr/bin/env python3 +# Copyright (c) 2019-2026 The Khronos Group Inc. +# SPDX-License-Identifier: Apache-2.0 + +from itertools import product + +from shared import PLATFORMS, TRUE_FALSE, VS_VERSION, make_win_artifact_name + +if __name__ == "__main__": + + for platform, uwp in product(PLATFORMS, TRUE_FALSE): + print(make_win_artifact_name(platform, uwp)) diff --git a/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/shared.py b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/shared.py new file mode 100644 index 0000000..bd4eb7f --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.azure-pipelines/shared/shared.py @@ -0,0 +1,26 @@ +# Copyright (c) 2019-2026 The Khronos Group Inc. +# SPDX-License-Identifier: Apache-2.0 + +import json +import sys + +VS_VERSION = 'Visual Studio 17 2022' + +PLATFORMS = ('Win32', 'x64', 'ARM64') + +TRUE_FALSE = (True, False) + + +def make_win_artifact_name(platform, uwp): + return 'loader_{}{}'.format( + platform.lower(), + '_uwp' if uwp else '', + ) + + +def output_json(data): + if len(sys.argv) == 2: + print( + "##vso[task.setVariable variable={};isOutput=true]{}".format(sys.argv[1], json.dumps(data))) + else: + print(json.dumps(data, indent=4)) diff --git a/shadps4-arm64-main/externals/openxr-sdk/.editorconfig b/shadps4-arm64-main/externals/openxr-sdk/.editorconfig new file mode 100644 index 0000000..7db6358 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.editorconfig @@ -0,0 +1,33 @@ +# Copyright (c) 2017-2026 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 + +# http://editorconfig.org +root = true + +[*] +charset = utf-8 +trim_trailing_whitespace = false +insert_final_newline = true + +[*.xml,*.rnc] +trim_trailing_whitespace = true + +[*.xml] +indent_style = space +trim_trailing_whitespace = true +indent_size = 4 + +[*.cmake,CMakeLists.txt] +indent_style = space +indent_size = 4 +trim_trailing_whitespace = true + +[*.sh] +trim_trailing_whitespace = true +end_of_line = lf + +[*.adoc] +trim_trailing_whitespace = true +indent_style = space +indent_size = 2 diff --git a/shadps4-arm64-main/externals/openxr-sdk/.git-blame-ignore-revs b/shadps4-arm64-main/externals/openxr-sdk/.git-blame-ignore-revs new file mode 100644 index 0000000..98c1c51 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.git-blame-ignore-revs @@ -0,0 +1,75 @@ +# Copyright 2021-2026 The Khronos Group Inc. +# +# SPDX-License-Identifier: CC-BY-4.0 + +# This file contains the commit IDs (on all OpenXR repos!) +# of "bulk" commits that should be excluded from blame, etc. to +# make it more useful. +# When adding new bulk changes, please follow the existing style, +# and do try to make sure that the bulk change is made +# **separate from a release commit** on all repos. +# See <https://git-scm.com/docs/git-blame#Documentation/git-blame.txt---ignore-revs-fileltfilegt> +# for how to use this, probably something like: +# git config blame.ignoreRevsFile .git-blame-ignore-revs + +## Old changes +0c93c42891ad6b95aee81709398ded7416c9f397 +767537d9523253de1615b01450a8b22c8e2cc6a2 + +## 1.0.17 - Fix XML indentation + +# Khronos GitLab +ae6fe8a4f2cfc3e5e0bb7da3de4d9067e861b5a3 + +# OpenXR-Docs +e8ddebd3c7ff6978e84c73e49c41c36ce4a01464 + +# OpenXR-SDK-Source +cc8e70f69de3ec536d5bd7cdebcd6e30d36dfcae + +# OpenXR-CTS +e28085d027d0e3b215858906b1ad7d98fb0483ff + + +## 1.0.17 - Sort return codes + +# Khronos GitLab +755ac4d86eb33340289fc0765391c31ce17959fc + +# OpenXR-Docs +bd1f05a6f5da8662c6969996177063a5a98bf0ea + +# OpenXR-SDK-Source +114c3a2829f51eb0e2508a99f98b2e14760ba2c2 + +# OpenXR-CTS +1224c0ba88b6f000a5f00f56c0dbb8265a6c6350 + + +## 1.0.27 - Bulk-apply PrettyRegistryXML + +# Khronos GitLab (commit also includes adding an extension) +ff2037bc6aa951610f4e21d133056d3f547d2374 + +# Khronos GitLab (finishing formatting) +4bb0766ec6d7101b17b0bc02ba04c86c4159bd16 + +# OpenXR-Docs +09b6b4bae7d691e1406ee6951e5ab8ed4e620ff3 + +# OpenXR-SDK-Source +2c1b77dcdc6ace701e4b08477e5fae5312a866b4 + +# OpenXR-CTS +e774b36cfc7bfc721e97de6c8435fcb14866e6fa + +# OpenXR-SDK +db11d03216666f2b574da46a39c4b565dbe90124 + +## 1.1.40 - Update to clang-format-14 + +# Khronos GitLab +22ba5c7abe1f43122d1eedebc093008d03aaad03 + +# OpenXR-CTS +e3ab3214c1307d60642ee939739740f5111bbb54 diff --git a/shadps4-arm64-main/externals/openxr-sdk/.gitattributes b/shadps4-arm64-main/externals/openxr-sdk/.gitattributes new file mode 100644 index 0000000..86f4497 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.gitattributes @@ -0,0 +1,36 @@ +# Copyright (c) 2017-2026 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 +* text=auto +*.txt text +*.c text +*.cpp text +*.h text +*.hpp text +*.inl text +*.adoc text +*.in text +*.json text +*.bat eol=crlf +*.cmd eol=crlf +*.vcproj eol=crlf +*.vcxproj eol=crlf +*.sln eol=crlf +*.sh eol=lf +*.png binary +# git-lfs big files +*.pdf filter=lfs diff=lfs merge=lfs -text +*.glb filter=lfs diff=lfs merge=lfs -text +src/conformance/**/*.png filter=lfs diff=lfs merge=lfs -text +specification/sources/images/XR_ANDROID_mouse_interaction_aim_drag.png filter=lfs diff=lfs merge=lfs -text +specification/sources/images/XR_ANDROID_mouse_interaction_aim_pose.png filter=lfs diff=lfs merge=lfs -text +src/conformance/conformance_test/composition_examples/irm_interactive.jpeg filter=lfs diff=lfs merge=lfs -text +# Shell/python scripts that don't end in .sh +specification/makeAllExts eol=lf +specification/makeExt eol=lf +specification/makeKHR eol=lf +specification/makeKHRAndKHX eol=lf +specification/makeReleaseArtifacts eol=lf +specification/makeSpec eol=lf +specification/checkMarkup eol=lf +specification/checkSpecLinks eol=lf diff --git a/shadps4-arm64-main/externals/openxr-sdk/.github/.java-version b/shadps4-arm64-main/externals/openxr-sdk/.github/.java-version new file mode 100644 index 0000000..98d9bcb --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.github/.java-version @@ -0,0 +1 @@ +17 diff --git a/shadps4-arm64-main/externals/openxr-sdk/.github/.java-version.license b/shadps4-arm64-main/externals/openxr-sdk/.github/.java-version.license new file mode 100644 index 0000000..9d891b7 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.github/.java-version.license @@ -0,0 +1,2 @@ +SPDX-FileCopyrightText: 2025 Collabora, Ltd. +SPDX-License-Identifier: CC0-1.0 diff --git a/shadps4-arm64-main/externals/openxr-sdk/.github/pull_request_template.md b/shadps4-arm64-main/externals/openxr-sdk/.github/pull_request_template.md new file mode 100644 index 0000000..1bb4ee6 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.github/pull_request_template.md @@ -0,0 +1,6 @@ +<!-- +Copyright (c) 2022-2026 The Khronos Group Inc. + +SPDX-License-Identifier: CC-BY-4.0 +--> +This is a derived repository, please open a corresponding pull request at [OpenXR-SDK-Source](https://github.com/KhronosGroup/OpenXR-SDK-Source) diff --git a/shadps4-arm64-main/externals/openxr-sdk/.github/scripts/CMakePresets.json b/shadps4-arm64-main/externals/openxr-sdk/.github/scripts/CMakePresets.json new file mode 100644 index 0000000..7670d40 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.github/scripts/CMakePresets.json @@ -0,0 +1,95 @@ +{ + "version": 3, + "cmakeMinimumRequired": { + "major": 3, + "minor": 21, + "patch": 0 + }, + "configurePresets": [ + { + "name": ".base-msvc", + "generator": "Visual Studio 18 2026", + "hidden": true, + "installDir": "$env{INSTALL_DIR}", + "cacheVariables": { + "DYNAMIC_LOADER": true, + "INSTALL_TO_ARCHITECTURE_PREFIXES": true, + "BUILD_ALL_EXTENSIONS": true + }, + "condition": { + "type": "equals", + "lhs": "${hostSystemName}", + "rhs": "Windows" + } + }, + { + "name": "win32", + "inherits": ".base-msvc", + "architecture": "Win32" + }, + { + "name": "win32_uwp", + "inherits": "win32", + "cacheVariables": { + "CMAKE_SYSTEM_NAME": "WindowsStore", + "CMAKE_SYSTEM_VERSION": "10.0.22000.0" + } + }, + { + "name": "x64", + "inherits": ".base-msvc", + "architecture": "x64" + }, + { + "name": "x64_uwp", + "inherits": "x64", + "cacheVariables": { + "CMAKE_SYSTEM_NAME": "WindowsStore", + "CMAKE_SYSTEM_VERSION": "10.0.22000.0" + } + }, + { + "name": "arm_uwp", + "inherits": ".base-msvc", + "architecture": "ARM", + "cacheVariables": { + "CMAKE_SYSTEM_NAME": "WindowsStore", + "CMAKE_SYSTEM_VERSION": "10.0.22000.0" + } + }, + { + "name": "arm64_uwp", + "inherits": ".base-msvc", + "architecture": "ARM64", + "cacheVariables": { + "CMAKE_SYSTEM_NAME": "WindowsStore", + "CMAKE_SYSTEM_VERSION": "10.0.22000.0" + } + }, + { + "name": ".base-cts-msvc", + "generator": "Visual Studio 18 2026", + "hidden": true, + "installDir": "$env{INSTALL_DIR}", + "cacheVariables": { + "DYNAMIC_LOADER": false, + "BUILD_ALL_EXTENSIONS": true + }, + "condition": { + "type": "equals", + "lhs": "${hostSystemName}", + "rhs": "Windows" + } + }, + { + "name": "cts-win32", + "inherits": ".base-cts-msvc", + "architecture": "Win32" + }, + { + "name": "cts-x64", + "inherits": ".base-cts-msvc", + "architecture": "x64" + } + ] +} diff --git a/shadps4-arm64-main/externals/openxr-sdk/.github/scripts/CMakePresets.json.license b/shadps4-arm64-main/externals/openxr-sdk/.github/scripts/CMakePresets.json.license new file mode 100644 index 0000000..312455c --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.github/scripts/CMakePresets.json.license @@ -0,0 +1,2 @@ +SPDX-FileCopyrightText: 2022 Collabora, Ltd +SPDX-License-Identifier: CC0-1.0 diff --git a/shadps4-arm64-main/externals/openxr-sdk/.github/scripts/generate_windows_matrix_build.py b/shadps4-arm64-main/externals/openxr-sdk/.github/scripts/generate_windows_matrix_build.py new file mode 100644 index 0000000..4a4d6bb --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.github/scripts/generate_windows_matrix_build.py @@ -0,0 +1,16 @@ +#!/usr/bin/env python3 +# Copyright (c) 2019-2026 The Khronos Group Inc. +# SPDX-License-Identifier: Apache-2.0 + +from itertools import product +import sys + +from shared import BUILD_CONFIGS, output_json + +if __name__ == "__main__": + + matrix = {"include": [{"preset": c.preset()} for c in BUILD_CONFIGS]} + var_name = None + if len(sys.argv) >= 2: + var_name = sys.argv[1] + output_json(matrix, variable_name=var_name) diff --git a/shadps4-arm64-main/externals/openxr-sdk/.github/scripts/install_vulkan.ps1 b/shadps4-arm64-main/externals/openxr-sdk/.github/scripts/install_vulkan.ps1 new file mode 100644 index 0000000..70740ba --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.github/scripts/install_vulkan.ps1 @@ -0,0 +1,36 @@ +# Copyright (c) 2019-2026 The Khronos Group Inc. +# SPDX-License-Identifier: Apache-2.0 + +$ErrorActionPreference = 'Stop' + +if (-not $env:VULKAN_SDK_VERSION) { + $env:VULKAN_SDK_VERSION = "1.1.114.0" +} + +$SDK_VER = $env:VULKAN_SDK_VERSION + +if (-not (Test-Path env:VULKAN_SDK)) { + if ($env:SYSTEM_DEFAULTWORKINGDIRECTORY) { + $env:VULKAN_SDK = "$env:SYSTEM_DEFAULTWORKINGDIRECTORY\vulkan_sdk\$SDK_VER" + } + else { + $env:VULKAN_SDK = Join-Path (Get-Location) "VulkanSDK\$SDK_VER" + } +} +$parent = Split-Path -Path $env:VULKAN_SDK +Write-Output "Trying for Vulkan SDK $SDK_VER" +$FN = "vksdk-$SDK_VER-lite.7z" +$URL = "https://people.collabora.com/~rpavlik/ci_resources/$FN" +if (-not (Test-Path "$env:VULKAN_SDK/Include/vulkan/vulkan.h")) { + Write-Output "Downloading $URL" + $wc = New-Object System.Net.WebClient + $wc.DownloadFile($URL, "$(Get-Location)\$FN") + + Write-Output "Extracting $FN in silent, blocking mode to $env:VULKAN_SDK" + Start-Process "c:\Program Files\7-Zip\7z" -ArgumentList "x", $FN, "-o$parent" -Wait +} +else { + Write-Output "$env:VULKAN_SDK found and contains header" +} + +Write-Output "VULKAN_SDK=$env:VULKAN_SDK" >> $env:GITHUB_ENV diff --git a/shadps4-arm64-main/externals/openxr-sdk/.github/scripts/organize_windows_artifacts.py b/shadps4-arm64-main/externals/openxr-sdk/.github/scripts/organize_windows_artifacts.py new file mode 100644 index 0000000..bfd5a7a --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.github/scripts/organize_windows_artifacts.py @@ -0,0 +1,43 @@ +#!/usr/bin/env python3 +# Copyright (c) 2019-2026 The Khronos Group Inc. +# SPDX-License-Identifier: Apache-2.0 + +from pathlib import Path +import shutil +import sys + +from shared import BUILD_CONFIGS + +CWD = Path.cwd() + +def move(src, dest): + + print(str(src), "->", str(dest)) + src.replace(dest) + + +if __name__ == "__main__": + + configs = {} + workspace = Path(sys.argv[1]) + outbase = Path(sys.argv[2]) + + common_copied = False + + for config in BUILD_CONFIGS: + platform_dirname = config.platform_dirname() + + name = config.win_artifact_name() + + artifact = workspace / "artifacts" / name + + if not common_copied: + # Start by copying the full tree over. + shutil.copytree(artifact, outbase, dirs_exist_ok=True) + common_copied = True + continue + + # lib files + shutil.copytree( + artifact / platform_dirname, outbase / platform_dirname, dirs_exist_ok=True + ) diff --git a/shadps4-arm64-main/externals/openxr-sdk/.github/scripts/shared.py b/shadps4-arm64-main/externals/openxr-sdk/.github/scripts/shared.py new file mode 100644 index 0000000..ee05c29 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.github/scripts/shared.py @@ -0,0 +1,67 @@ +# Copyright (c) 2019-2026 The Khronos Group Inc. +# SPDX-License-Identifier: Apache-2.0 + +import json +import sys +import os +from dataclasses import dataclass +from itertools import product + +VS_VERSION = "Visual Studio 17 2022" + +PLATFORMS = ("Win32", "x64", "ARM64") + +TRUE_FALSE = (True, False) + + +@dataclass +class BuildConfig: + arch: str + uwp: bool + + def should_skip(self) -> bool: + # ARM/ARM64 is only built for the UWP platform. + return "ARM" in self.arch and not self.uwp + + # can switch to just doing x64 for speed of testing + # return self.arch != "x64" + + def has_cts_build(self) -> bool: + # No UWP CTS right now + return not self.uwp and not self.should_skip() + + def preset(self) -> str: + if self.uwp: + return f"{self.arch.lower()}_uwp" + + return self.arch.lower() + + def win_artifact_name(self) -> str: + return f"loader_{self.preset()}" + + def win_cts_artifact_name(self) -> str: + return f"loader_{self.preset()}" + + def platform_dirname(self) -> str: + if self.uwp: + return f"{self.arch}_uwp" + return self.arch + + +_UNFILTERED_BUILD_CONFIGS = [ + BuildConfig(arch, uwp) for arch, uwp in product(PLATFORMS, TRUE_FALSE) +] + +BUILD_CONFIGS = [c for c in _UNFILTERED_BUILD_CONFIGS if not c.should_skip()] + +CTS_BUILD_CONFIGS = [c for c in _UNFILTERED_BUILD_CONFIGS if c.has_cts_build()] + + +def output_json(data, variable_name=None): + if variable_name: + envfile = os.getenv("GITHUB_ENV") + assert envfile + with open(envfile, "w", encoding="utf-8") as fp: + fp.write(f"{variable_name}={json.dumps(data)}") + else: + print(json.dumps(data, indent=4)) diff --git a/shadps4-arm64-main/externals/openxr-sdk/.github/workflows/android.yml b/shadps4-arm64-main/externals/openxr-sdk/.github/workflows/android.yml new file mode 100644 index 0000000..3426dfb --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.github/workflows/android.yml @@ -0,0 +1,68 @@ +# Copyright 2021-2025, Collabora, Ltd. +# SPDX-License-Identifier: CC0-1.0 + +name: Android +on: + workflow_call: + inputs: + release: + description: "Is this a release to publish?" + type: boolean + default: false + snapshot: + description: "Is this a snapshot to publish?" + type: boolean + default: false + debug: + type: boolean + description: "Should we make a debug configured build?" + default: true + +jobs: + # Loader + loader: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v7 + - name: Get modern CMake and Ninja + uses: "lukka/get-cmake@v4.2.3" + + # Do this before building aar since it affects the version + - name: Touch SNAPSHOT marker file + if: "!inputs.release" + run: "touch SNAPSHOT" + + - name: "Build AAR" + run: "./maintainer-scripts/build-aar.sh" + + - name: Upload bare AAR + uses: "actions/upload-artifact@v7" + with: + name: AAR and POM + path: openxr_loader_for_android* + + # Hello XR + build-helloxr: + runs-on: ubuntu-latest + steps: + - uses: "actions/checkout@v7" + - name: "Get modern CMake and Ninja" + uses: "lukka/get-cmake@v4.2.3" + - name: "set up JDK" + uses: "actions/setup-java@v5" + with: + java-version-file: ".github/.java-version" + distribution: "temurin" + # Also performs Gradle wrapper validation + - uses: "gradle/actions/setup-gradle@v5" + + # HelloXR OpenGLES version + - name: Build HelloXR OpenGLES for Android + run: "cd src/tests/hello_xr && ./gradlew assembleOpenGLES${{ inputs.release && 'Release' || 'Debug' }}" + + - name: Upload HelloXR OpenGLES (debug) for Android + if: "!inputs.release" + uses: "actions/upload-artifact@v7" + with: + name: HelloXR OpenGLES Android + path: "src/tests/hello_xr/build/outputs/apk/OpenGLES/debug/*.apk" diff --git a/shadps4-arm64-main/externals/openxr-sdk/.github/workflows/check_clang_format_and_codespell.yml b/shadps4-arm64-main/externals/openxr-sdk/.github/workflows/check_clang_format_and_codespell.yml new file mode 100644 index 0000000..8480456 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.github/workflows/check_clang_format_and_codespell.yml @@ -0,0 +1,37 @@ +# Copyright (c) 2019-2026 The Khronos Group Inc. +# SPDX-License-Identifier: Apache-2.0 + +name: Check code formatting and spelling + +on: + workflow_call: + +jobs: + clang-format: + runs-on: ubuntu-latest + container: + image: khronosgroup/docker-images:openxr.20260415@sha256:800fd68bd1b16b426555158f4aa06b2ef1c150fba922d7a11361fc85f6ba0bcd + + steps: + - uses: actions/checkout@v7 + with: + lfs: true + + - run: ./runClangFormat.sh + name: Run clang-format + + - run: git diff --patch --exit-code > clang-format.patch + name: Save changes as diff + + # In case of failure (clang-format changes needed) do these two things + - run: echo "The following files need clang-formatting:"; sed -n -e "s/^diff.* b\///p" ${{ runner.temp }}/clang-format.patch + if: ${{ failure() }} + - name: Publish diff + if: ${{ failure() }} + uses: actions/upload-artifact@v7 + with: + path: ${{ runner.temp }}/clang-format.patch + name: clang-format-changes + + - name: Run Codespell script + run: ./checkCodespell diff --git a/shadps4-arm64-main/externals/openxr-sdk/.github/workflows/msvc-build-preset.yml b/shadps4-arm64-main/externals/openxr-sdk/.github/workflows/msvc-build-preset.yml new file mode 100644 index 0000000..6b761a9 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.github/workflows/msvc-build-preset.yml @@ -0,0 +1,66 @@ +# Copyright 2021-2025, Collabora, Ltd. +# SPDX-License-Identifier: CC0-1.0 + +on: + workflow_call: + inputs: + preset: + description: "CMake build preset" + type: string + required: true + buildType: + description: "Build configuration" + type: string + required: true + default: RelWithDebInfo + artifactName: + description: "Artifact name to upload to." + type: string + required: false + subdir: + description: "Subdir of the workspace to upload as an artifact." + type: string + default: install + +jobs: + msvc-build: + runs-on: windows-latest + env: + VULKAN_SDK_VERSION: "1.1.114.0" + INSTALL_DIR: "${{ github.workspace }}/install" + steps: + - uses: actions/checkout@v7 + with: + lfs: true + fetch-tags: "${{ !github.event.release }}" + fetch-depth: "${{ github.event.release && '0' || '1'}}" + + - name: Get modern CMake and Ninja + uses: lukka/get-cmake@v4.2.3 + + - name: Add msbuild to PATH + uses: microsoft/setup-msbuild@v3 + + - name: Install Vulkan SDK + run: ./.github/scripts/install_vulkan.ps1 + if: "${{ !contains( inputs.preset, 'uwp') }}" + working-directory: "${{ github.workspace }}" + shell: pwsh + + - name: Generate build system + shell: pwsh + run: | + Copy-Item .github/scripts/CMakePresets.json . + cmake --fresh --preset ${{ inputs.preset }} -S . -B $env:RUNNER_TEMP + - name: Build + run: "cmake --build $env:RUNNER_TEMP --parallel --clean-first --config ${{ inputs.buildType }}" + + - name: Install + run: "cmake --build $env:RUNNER_TEMP --parallel --config ${{ inputs.buildType }} --target install" + + - name: Upload Artifacts + uses: actions/upload-artifact@v7 + if: inputs.artifactName + with: + name: "${{ inputs.artifactName }}" + path: "${{ github.workspace }}/${{ inputs.subdir }}" diff --git a/shadps4-arm64-main/externals/openxr-sdk/.github/workflows/windows-matrix.yml b/shadps4-arm64-main/externals/openxr-sdk/.github/workflows/windows-matrix.yml new file mode 100644 index 0000000..d792488 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.github/workflows/windows-matrix.yml @@ -0,0 +1,84 @@ +# Copyright 2021-2023, Collabora, Ltd. +# SPDX-License-Identifier: CC0-1.0 + +name: Windows builds +on: + workflow_call: + inputs: + organizeAndRelease: + description: "Should we organize and release our artifacts?" + type: boolean + default: false + workflow_dispatch: + +jobs: + # generate_matrix: + # runs-on: ubuntu-latest + # outputs: + # matrix: "${{ steps.set-matrix.outputs.matrix }}" + # steps: + # - uses: "actions/checkout@v7" + # - id: set-matrix + # run: "python3 .github/scripts/generate_windows_matrix_build.py matrix" + msvc-build: + # needs: generate_matrix + strategy: + fail-fast: true + # TODO: Fix matrix generation? Broke recently due to changes in github actions + # matrix: "${{fromJson(needs.generate_matrix.outputs.matrix)}}" + matrix: + preset: + - win32 + - x64 + - win32_uwp + - x64_uwp + - arm64_uwp + # - arm_uwp + + uses: "./.github/workflows/msvc-build-preset.yml" + with: + preset: "${{ matrix.preset }}" + artifactName: "loader_${{ matrix.preset }}" + buildType: "RelWithDebInfo" + + organize-and-release-artifacts: + if: inputs.organizeAndRelease + needs: + - msvc-build + runs-on: ubuntu-22.04 + steps: + - uses: "actions/checkout@v7" + + - name: Retrieve artifacts + uses: "actions/download-artifact@v8" + with: + path: artifacts + + - name: Organize artifacts + run: 'python .github/scripts/organize_windows_artifacts.py "${{ github.workspace }}" "${{ github.workspace }}/openxr_loader"' + + - name: Upload combined artifact + uses: "actions/upload-artifact@v7" + with: + name: openxr_loader_windows + path: "${{ github.workspace }}/openxr_loader" + + # NuGet stuff now + + - name: Setup NuGet + uses: "NuGet/setup-nuget@12c57947e9458a5b976961b08ea0706a17dd71ae" + with: + nuget-version: "5.x" + + - name: Stage loader and headers for NuGet + shell: pwsh + run: '${{ github.workspace }}/.azure-pipelines/nuget/stage_nuget.ps1 "${{ github.workspace }}/openxr_loader" "${{ github.workspace }}/specification/Makefile" "${{ github.workspace }}/openxr_loader_staging"' + + - name: Pack NuGet package + run: 'nuget pack "${{ github.workspace }}/openxr_loader_staging/OpenXR.Loader.nuspec" -OutputDirectory "${{ github.workspace }}/nuget"' + + - name: Upload NuGet artifact + uses: "actions/upload-artifact@v7" + with: + name: NuGet + path: "${{ github.workspace }}/nuget" diff --git a/shadps4-arm64-main/externals/openxr-sdk/.gitignore b/shadps4-arm64-main/externals/openxr-sdk/.gitignore new file mode 100644 index 0000000..933da00 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.gitignore @@ -0,0 +1,96 @@ +# Copyright (c) 2017-2026 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 + +/build/ +build*/ +CMakeLists.txt.user +CMakeCache.txt +CMakeFiles +*/CMakeFiles +*.orig +.* +*~ +*.tar +*.tar.gz +*.log +pregen/ +sources-jar/ +docs-jar/ +generated-includes +cmake_install.cmake +cmake_uninstall.cmake +cmake-build-* +specification/vendor/bundle/ + +# Marker file for a snapshot build +SNAPSHOT + +# Cached python scripts in bytecode form +*.pyc +applyfixes.sh + +# Files related to building examples +specification/**/*.c +specification/**/*.cpp +specification/**/*.o +specification/examples.mk + +# Files related to pytest +specification/scripts/.cache + +# VS 2019 CMake artifacts +out/build/ +out/install/ + +# VS misc +*.sln +*.pyproj +*.vcxproj +*.vcxproj.filters +CMakeSettings.json +CppProperties.json + +# Gradle +.cxx/ +.gradle/ +local.properties + +# Don't ignore these things +!.*.license +!.artifact-bot.md +!.appveyor.yml +!.azure-pipelines/ +!.azure-pipelines/nuget/NugetTemplate/build +!.clang-format +!.clang-tidy +!.cmake-format.py +!.editorconfig +!.git-blame-ignore-revs +!.git-keep +!.gitattributes +!.github +!.gitignore +!.gitlab +!.gitlab-ci +!.gitlab-ci.yml +!.mailmap +!.markdownlint.yaml +!.proclamation.json +!.reuse +!/.env +!.java-version + +# Output artifact +*.aar +*.pom +clang-format-patches/ +/*.jar +/*.diff +/*.log +/*.pdf +!src/loader/*.pom +!src/api_layers/**/*.pom + +# Key stores +*.jks diff --git a/shadps4-arm64-main/externals/openxr-sdk/.mailmap b/shadps4-arm64-main/externals/openxr-sdk/.mailmap new file mode 100644 index 0000000..a504c55 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.mailmap @@ -0,0 +1,35 @@ +# Copyright 2017-2026 The Khronos Group Inc. +# +# SPDX-License-Identifier: CC-BY-4.0 +# +# See mailmap docs: https://git-scm.com/docs/gitmailmap +# Please keep in sorted order. +# Generally, only add lines, unless you want to change the spelling +# of your name. +# Test by running git shortlog -s -e +# +# This mailmap is for **public repos** and should only be tested there. + +Blake Taylor <rotaylor@magicleap.com> +Bradley Austin Davis <bdavis@saintandreas.org> +Bryce Hutchings <bryceh@microsoft.com> +Bryce Hutchings <bryceh@microsoft.com> <5100250+brycehutchings@users.noreply.github.com> +Bryce Hutchings <bryceh@microsoft.com> <me@bryce.ws> +Daniel Willmott <39023874+danwillm@users.noreply.github.com> +Ivan Chupakhin <ivan.chupakhin@almalence.com> +Ivan Chupakhin <ivan.chupakhin@almalence.com> <Gurinchi@gmail.com> +Kevin Qin <zheng.qin@microsoft.com> +Kevin Qin <zheng.qin@microsoft.com> <zheqi@microsoft.com> +Khronos Group Web Services <webservices@khronos.org> +Khronos Group Web Services <webservices@khronos.org> <webmaster@khronos.org> +Liu Knox <dengkail@qti.qualcomm.com> <dengkail@qti.qualcom.com> +OC Lin <oc.lin@acer.com> +Rachel Huang <rachel.huang@huawei.com> +Rylie Pavlik <rylie.pavlik@collabora.com> +Rylie Pavlik <rylie.pavlik@collabora.com> <ryan.pavlik@collabora.com> +Rylie Pavlik <rylie.pavlik@collabora.com> <ryan.pavlik@gmail.com> +Rylie Pavlik <rylie@ryliepavlik.com> <ryan@ryanpavlik.com> +Yin Li <yl@microsoft.com> +samuel degrande <samuel.degrande@univ-lille.fr> +utzcoz <utzcoz@outlook.com> +utzcoz <utzcoz@outlook.com> <43091780+utzcoz@users.noreply.github.com> diff --git a/shadps4-arm64-main/externals/openxr-sdk/.reuse/dep5 b/shadps4-arm64-main/externals/openxr-sdk/.reuse/dep5 new file mode 100644 index 0000000..0bc1cb4 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/.reuse/dep5 @@ -0,0 +1,134 @@ +Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ +Upstream-Name: OpenXR +Upstream-Contact: Rylie Pavlik <openxr-speceditor AT khronos DOT org> +Source: https://registry.khronos.org/OpenXR/ + +Files: changes/conformance/* + changes/major/* + changes/registry/* + changes/sdk/* + changes/specification/* + changes/README.md + changes/template.md + HOTFIX +Copyright: 2019-2026 The Khronos Group Inc. +License: CC-BY-4.0 + +Files: specification/config/copyright-spec.adoc +Copyright: 2014-2026 The Khronos Group Inc +License: LicenseRef-KhronosSpecCopyright-WithNormativeWording-v10 + +Files: src/tests/hello_xr/android_resources/vulkan/mipmap-xxhdpi/ic_helloxr_launcher.png + src/tests/hello_xr/android_resources/vulkan/mipmap-mdpi/ic_helloxr_launcher.png + src/tests/hello_xr/android_resources/vulkan/mipmap-xhdpi/ic_helloxr_launcher.png + src/tests/hello_xr/android_resources/vulkan/mipmap-hdpi/ic_helloxr_launcher.png + src/tests/hello_xr/android_resources/vulkan/mipmap-xxxhdpi/ic_helloxr_launcher.png + src/tests/hello_xr/android_resources/opengles/mipmap-xxhdpi/ic_helloxr_launcher.png + src/tests/hello_xr/android_resources/opengles/mipmap-mdpi/ic_helloxr_launcher.png + src/tests/hello_xr/android_resources/opengles/mipmap-xhdpi/ic_helloxr_launcher.png + src/tests/hello_xr/android_resources/opengles/mipmap-hdpi/ic_helloxr_launcher.png + src/tests/hello_xr/android_resources/opengles/mipmap-xxxhdpi/ic_helloxr_launcher.png +Copyright: Copyright (c) 2020-2026 The Khronos Group Inc. + Copyright (c) 2020, Google +License: Apache-2.0 +Comment: Based on a Material Icons asset ("emoji-people") with added text + in "Miriam Libre" Bold, converted to path, and manually simplified. + Rasterized with Android Studio. + +Files: src/external/catch2/* +Copyright: Copyright Catch2 Authors +License: BSL-1.0 +Comment: Unmodified, vendored copy of Catch2 v3.11.0 + +Files: src/external/jsoncpp/* +Copyright: 2007-2010 Baptiste Lepilleur and The JsonCpp Authors +License: MIT OR LicenseRef-jsoncpp-public-domain +Comment: Unmodified, vendored copy of jsoncpp 1.9.6 + +Files: src/external/tinygltf/README.md + src/external/tinygltf/tiny_gltf.cc + src/external/tinygltf/tiny_gltf.h +Copyright: 2015-Present, Syoyo Fujita, Aurélien Chatelain and many contributors +License: MIT +Comment: Unmodified, vendored copy of a subset of the tiny-gltf repo v2.9.6 + +Files: src/external/d3dx12/* +Copyright: Copyright (c) Microsoft Corporation. +License: MIT +Comment: Unmodified, vendored copy of d3dx12.h from directx-vs-templates commit 86b9c45 + This repo includes ifdefs to improve compatibility with older Windows SDK versions. + +Files: src/external/mikktspace/* +Copyright: 2011 by Morten S. Mikkelsen +License: Zlib +Comment: Unmodified, vendored copy of MikkTSpace commit 3e895b4 + +Files: src/external/basis_universal/* +Copyright: 2019-2021 Binomial LLC +License: Apache-2.0 +Comment: Unmodified, vendored subset of basis_universal commit v1_50_0 + +Files: src/external/basis_universal/zstd/* +Copyright: 2016-2021, Yann Collet, Facebook, Inc. +License: BSD-3-Clause +Comment: Vendored copy of single-file libraries included in the basis_universal repo. + +Files: src/external/jnipp/* +Copyright: 2016-2020, Mitchell Dowd + 2020, Collabora, Ltd. +License: MIT +Comment: Unmodified, vendored copy of commit v1.0.0-13-gcdd6293 + +Files: src/external/metal-cpp/* +Copyright: Copyright 2020-2022 Apple Inc. +License: Apache-2.0 +Comment: Unmodified, vendored copy of metal-cpp_macOS13_iOS16.zip + +Files: external/python/jinja2/* + external/python/Jinja2-2.11.3.dist-info/* +Copyright: 2013-2019 by the Jinja team + 2007 Pallets +License: BSD-3-Clause + +Files: external/python/markupsafe/* + external/python/MarkupSafe-1.1.1.dist-info/* +Copyright: 2010 Pallets +License: BSD-3-Clause + +Files: external/python/pyparsing/* + external/python/pyparsing-3.1.2.dist-info/* +Copyright: 2003-2022, Paul T. McGuire <ptmcg.gm+pyparsing@gmail.com> +License: BSD-3-Clause + +Files: specification/sources/chapters/extensions/epic/epic_view_configuration_fov.adoc +Copyright: 2020, Epic Games, Inc. +License: CC-BY-4.0 +Comment: In-line license comments requested, https://gitlab.khronos.org/openxr/openxr/-/issues/1422 + +Files: specification/sources/chapters/extensions/ext/ext_performance_settings.adoc + specification/sources/chapters/extensions/ext/ext_thermal_query.adoc +Copyright: 2017-2026 The Khronos Group Inc. +License: CC-BY-4.0 +Comment: In-line license comments requested, https://gitlab.khronos.org/openxr/openxr/-/issues/1419 + +Files: src/conformance/platform_specific/android_resources/mipmap-hdpi/* + src/conformance/platform_specific/android_resources/mipmap-mdpi/* + src/conformance/platform_specific/android_resources/mipmap-xhdpi/* + src/conformance/platform_specific/android_resources/mipmap-xxhdpi/* + src/conformance/platform_specific/android_resources/mipmap-xxxhdpi/* +Copyright: 2020-2026 The Khronos Group Inc. + 2020, Google +License: Apache-2.0 +Comment: Generated .png versions of an icon, created in Android Studio + based on a Material Icons asset. + +Files: specification/scripts/vuidCounts.py +Copyright: 2022-2026 The Khronos Group Inc. +License: Apache-2.0 +Comment: File automatically rewritten by VUID assignment. + +Files: src/external/sanitizers-cmake/* +Copyright: 2013 Matt Arsenault + 2015-2016 RWTH Aachen University, Federal Republic of Germany +License: MIT +Comment: SPDX-License-Identifier missing. diff --git a/shadps4-arm64-main/externals/openxr-sdk/CHANGELOG.SDK.md b/shadps4-arm64-main/externals/openxr-sdk/CHANGELOG.SDK.md new file mode 100644 index 0000000..292ddcc --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/CHANGELOG.SDK.md @@ -0,0 +1,3645 @@ +# Changelog for OpenXR-SDK-Source and OpenXR-SDK Repo + +<!-- +Copyright (c) 2019-2026 The Khronos Group Inc. + +SPDX-License-Identifier: CC-BY-4.0 +--> + +Update log for the OpenXR-SDK-Source and OpenXR-SDK repo on GitHub. Updates are +in reverse chronological order starting with the latest public release. + +Note that only changes relating to the loader and some of the build changes will +affect the OpenXR-SDK repository. Changes mentioned in this changelog related to +hello_xr, API layers, and the loader tests do *not* apply to the OpenXR-SDK +repository. + +This summarizes the periodic public updates, not individual commits. Updates +on GitHub are generally done as single large patches at the release point, +collecting together the resolution of many Khronos internal issues, +along with any public pull requests that have been accepted. +In this repository in particular, since it is primarily software, +pull requests may be integrated as they are accepted even between periodic updates. + +## OpenXR SDK 1.1.63 (2026-09-01) + +This release primarily contains a large number of new extensions, including +four new ratified extensions, and support for those through the generated parts +of API layers in the SDK. SDK-specific changes include updates to the +`list_json` tool. + +- SDK + - Improvement: Loader: Remove duplicate null check for `outgoing_count` in + `GetApiLayerProperties`. + ([internal MR 4256](https://gitlab.khronos.org/openxr/openxr/merge_requests/4256)) + - Improvement: Minor usability improvements to "list_json" tool. + ([internal MR 4410](https://gitlab.khronos.org/openxr/openxr/merge_requests/4410), + [internal MR 3289](https://gitlab.khronos.org/openxr/openxr/merge_requests/3289)) + - Improvement: Allow `runClangTidy.sh` to run with clang-tidy 18. + ([internal MR 4433](https://gitlab.khronos.org/openxr/openxr/merge_requests/4433)) + - Improvement: Allow `runClangTidy.sh` to run with `-modernize-use-scoped-lock` + enabled. + ([internal MR 4435](https://gitlab.khronos.org/openxr/openxr/merge_requests/4435)) +- Registry + - New ratified Khronos extension: `XR_KHR_extended_result_name_lengths` + ([internal MR 3964](https://gitlab.khronos.org/openxr/openxr/merge_requests/3964)) + - New ratified multi-vendor extensions: `XR_EXT_spatial_container`, + `XR_EXT_spatial_container_self_rendering` + ([internal MR 3712](https://gitlab.khronos.org/openxr/openxr/merge_requests/3712), + [internal MR 4472](https://gitlab.khronos.org/openxr/openxr/merge_requests/4472)) + - New ratified multi-vendor extension: `XR_EXT_spatial_image_tracking` + ([internal MR 3805](https://gitlab.khronos.org/openxr/openxr/merge_requests/3805)) + - New vendor extension: `XR_BD_spatial_light_estimation` + ([internal MR 3814](https://gitlab.khronos.org/openxr/openxr/merge_requests/3814)) + - New vendor extension: `XR_BD_camera_image` + ([internal MR 4089](https://gitlab.khronos.org/openxr/openxr/merge_requests/4089)) + - New vendor extension: `XR_SONY_hdr_metadata` + ([internal MR 4172](https://gitlab.khronos.org/openxr/openxr/merge_requests/4172)) + - Change: Add new semantic definitions including keyboard, mouse, and laptop in + `XrSemanticLabelBD`. + ([internal MR 4221](https://gitlab.khronos.org/openxr/openxr/merge_requests/4221)) + - Chore: Reserve extension numbers. + ([internal MR 4420](https://gitlab.khronos.org/openxr/openxr/merge_requests/4420), + [internal MR 4421](https://gitlab.khronos.org/openxr/openxr/merge_requests/4421)) + - Fix: Missing comments for `XrResult` error codes added by + `XR_ANDROID_google_cloud_auth`, `XR_ANDROID_geospatial`, and + `XR_ANDROID_geospatial_anchor`. + ([internal MR 4438](https://gitlab.khronos.org/openxr/openxr/merge_requests/4438)) + - Fix: Always output forward slashes in relative paths when merging registry. + ([internal MR 4451](https://gitlab.khronos.org/openxr/openxr/merge_requests/4451)) + +## OpenXR SDK 1.1.62 (2026-07-31) + +This release includes a new vendor extension, an important fix to several vendor +extension added in the previous release, a loader design doc clarification, and +some software fixes and cleanup. For extension authors, there are workflow +improvements: extensions may now be developed in their own "fragment" XML file +and referenced from `xr.fragmented.xml`. Provided tooling processes this file to +generate the all-inclusive `xr.xml` previously edited directly. This reduces the +merge conflicts seen during extension development and makes review easier, +without requiring changes to tools expecting the conventional combined XML file. + +- SDK + - Fix: Only include EGL headers in `xr_dependencies.h` when using EGL or GLES. + ([internal MR 4387](https://gitlab.khronos.org/openxr/openxr/merge_requests/4387)) + - Improvement: Add `src/common/platform_exports.h` to de-duplicate platform + specific export flags. + ([internal MR 4323](https://gitlab.khronos.org/openxr/openxr/merge_requests/4323)) + - Improvement: Add additional description of Android API layer support. + ([internal MR 4373](https://gitlab.khronos.org/openxr/openxr/merge_requests/4373)) + - Improvement: Deduplicate `.def`, `.expsym`, and `.map` files used for API + layers in the SDK. + ([internal MR 4389](https://gitlab.khronos.org/openxr/openxr/merge_requests/4389), + [internal MR 3289](https://gitlab.khronos.org/openxr/openxr/merge_requests/3289)) +- Registry + - Change: XML registry `xr.xml` is now checked in after being constructed from + `xr.fragmented.xml` and multiple per-extension XML file fragments, for reduced + conflicts during development. The schema of `xr.xml` has not changed. Be sure + to run `specification/scripts/merge-registry.sh` after editing + `xr.fragmented.xml` or one of the fragments, as most tooling still uses the + merged XML registry. + ([internal MR 4161](https://gitlab.khronos.org/openxr/openxr/merge_requests/4161)) + - Chore: Register `DXR` author ID for The DisplayXR Project. + ([OpenXR-Docs PR 201](https://github.com/KhronosGroup/OpenXR-Docs/pull/201)) + - Fix: Resolve inconsistency between extension numbers for META vendor extensions + (`XR_META_hand_tracking_wide_motion_mode2`, + `XR_META_hand_tracking_frequency_hint`, + `XR_META_hand_tracking_unextrapolated_poses`). + ([internal MR 4380](https://gitlab.khronos.org/openxr/openxr/merge_requests/4380)) + - Fix: Add `XR_ERROR_LIMIT_REACHED` as an valid return for + `xrAcquireEnvironmentDepthImageMETA` matching API description. + ([internal MR 4414](https://gitlab.khronos.org/openxr/openxr/merge_requests/4414)) + - Improvement: Move `XR_ANDROID_trackables` to extension fragment XML file. + ([internal MR 4161](https://gitlab.khronos.org/openxr/openxr/merge_requests/4161)) + - Improvement: Add explicit type includes for types that are implicitly included + to improve generated documentation. + ([internal MR 4406](https://gitlab.khronos.org/openxr/openxr/merge_requests/4406), + [internal MR 4413](https://gitlab.khronos.org/openxr/openxr/merge_requests/4413)) + - New vendor extension: `XR_SONY_swapchain_color_space` + ([internal MR 4171](https://gitlab.khronos.org/openxr/openxr/merge_requests/4171)) + +## OpenXR SDK 1.1.61 (2026-07-02) + +This release marks the initial publication of the development tool API layers +for easier usage by developers for Android/AOSP-based systems. A small addition +to the reflection headers is also included, along with support for new and +revised vendor extensions. + +- SDK + - Addition: Build AAR files of development API layers and publish to Maven + Central on release. A line like + `implementation 'org.khronos.openxr:apilayer_core_validation:1.1.61'` + (or `apilayer_api_dump` or `apilayer_best_practices_validation` equivalently) + will bundle a layer with your application and enable it automatically as an implicit layer. + ([internal MR 4136](https://gitlab.khronos.org/openxr/openxr/merge_requests/4136)) + - Loader: Fix: Remove redundant null checks in `initializePlatform`. + ([internal MR 4261](https://gitlab.khronos.org/openxr/openxr/merge_requests/4261)) +- Registry + - Fix: Typos in enum value names for `XrTrackingOptimizationSettingsHintQCOM`. + Original names left as aliases for source compatibility. + ([internal MR 4186](https://gitlab.khronos.org/openxr/openxr/merge_requests/4186)) + - Improvement: `XR_LIST_FUNCTIONS_` macros in the reflection header are now + generated for all features, even those lacking functions. + ([internal MR 4329](https://gitlab.khronos.org/openxr/openxr/merge_requests/4329)) + - New vendor extension: `XR_ANDROID_spatial_discovery_bounds` + ([internal MR 3520](https://gitlab.khronos.org/openxr/openxr/merge_requests/3520)) + - New vendor extension: `XR_BD_body_tracking_auxiliary_metrics` + ([internal MR 3756](https://gitlab.khronos.org/openxr/openxr/merge_requests/3756)) + - New vendor extension: `XR_BD_dynamic_object_tracking` + ([internal MR 3944](https://gitlab.khronos.org/openxr/openxr/merge_requests/3944)) + - New vendor extension: `XR_BD_dynamic_object_keyboard` + ([internal MR 3944](https://gitlab.khronos.org/openxr/openxr/merge_requests/3944)) + - New vendor extension: `XR_BD_dynamic_object_mouse` + ([internal MR 3944](https://gitlab.khronos.org/openxr/openxr/merge_requests/3944)) + - New vendor extension: `XR_META_hand_tracking_frequency_hint` + ([internal MR 4110](https://gitlab.khronos.org/openxr/openxr/merge_requests/4110)) + - New vendor extension: `XR_META_hand_tracking_unextrapolated_poses` + ([internal MR 4113](https://gitlab.khronos.org/openxr/openxr/merge_requests/4113)) + - New vendor extension: `XR_META_hand_tracking_wide_motion_mode2` + ([internal MR 4114](https://gitlab.khronos.org/openxr/openxr/merge_requests/4114)) + - New vendor extension: `XR_ANDROID_google_cloud_auth` + ([internal MR 4200](https://gitlab.khronos.org/openxr/openxr/merge_requests/4200)) + - New vendor extension: `XR_ANDROID_geospatial` + ([internal MR 4201](https://gitlab.khronos.org/openxr/openxr/merge_requests/4201)) + - New vendor extension: `XR_ANDROID_geospatial_anchor` + ([internal MR 4214](https://gitlab.khronos.org/openxr/openxr/merge_requests/4214)) + - Schematron: Add exception for the comments of a behavior-only + `XrSpatialComponentTypeEXT`. + ([internal MR 4353](https://gitlab.khronos.org/openxr/openxr/merge_requests/4353)) + +## OpenXR SDK 1.1.60 (2026-05-20) + +This release contains support for a new multi-vendor extension, as well as many +fixes and cleanups to the layers and loader. + +- SDK + - API Dump Layer: Fix: Prevent runtime failure when encountering an unknown + XrStruct. + ([internal MR 4301](https://gitlab.khronos.org/openxr/openxr/merge_requests/4301)) + - API Dump Layer: Fix: Prevent crashes when using extension function pointers + without the extension enabled. + ([internal MR 4301](https://gitlab.khronos.org/openxr/openxr/merge_requests/4301), + [internal issue 2524](https://gitlab.khronos.org/openxr/openxr/issues/2524)) + - API Dump Layer: Fix: Data race due to map access outside the mutex lock in both + create and destroy paths for handle dispatch maps. + ([internal MR 4301](https://gitlab.khronos.org/openxr/openxr/merge_requests/4301)) + - API Dump Layer: Fix: Generated code attempting to read uninitialized `char*` + buffers. + ([internal MR 4301](https://gitlab.khronos.org/openxr/openxr/merge_requests/4301)) + - Best Practices Layer: Fix: Resolve invalid reference. + ([internal MR 4273](https://gitlab.khronos.org/openxr/openxr/merge_requests/4273), + [internal issue 2683](https://gitlab.khronos.org/openxr/openxr/issues/2683), + [OpenXR-SDK-Source issue 588](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/588)) + - Improvement: Loader: Minor code cleanups without functional change. + ([internal MR 4264](https://gitlab.khronos.org/openxr/openxr/merge_requests/4264)) + - Improvement: Enable `-Wc++20-extensions`. + ([internal MR 4265](https://gitlab.khronos.org/openxr/openxr/merge_requests/4265)) + - Improvement: Enable sanitizers for all CMake projects. + ([internal MR 4296](https://gitlab.khronos.org/openxr/openxr/merge_requests/4296), + [internal MR 2743](https://gitlab.khronos.org/openxr/openxr/merge_requests/2743)) + - Improvement: Add CMake test to run the CTS with the + `XR_APILAYER_LUNARG_api_dump` layer and test runtime (when layer and CTS are in + a single unified repo). + ([internal MR 4301](https://gitlab.khronos.org/openxr/openxr/merge_requests/4301)) + - Improvement: Add CMake test to run the CTS with the + `XR_APILAYER_LUNARG_core_validation` layer and test runtime (when layer and CTS + are in a single unified repo). + ([internal MR 4306](https://gitlab.khronos.org/openxr/openxr/merge_requests/4306)) + - Loader: Improvement: Refactor `LoaderXrGetInstanceProcAddr` to avoid repeated + `strcmp` on names and a hypothetical null dereference. + ([internal MR 3132](https://gitlab.khronos.org/openxr/openxr/merge_requests/3132)) + - Loader: Improvement: Several code cleanups and optimizations. + ([internal MR 4254](https://gitlab.khronos.org/openxr/openxr/merge_requests/4254), + [internal MR 4255](https://gitlab.khronos.org/openxr/openxr/merge_requests/4255), + [internal MR 4257](https://gitlab.khronos.org/openxr/openxr/merge_requests/4257), + [internal MR 4263](https://gitlab.khronos.org/openxr/openxr/merge_requests/4263)) + - Loader: Fix: Use `strtoul` instead of `atoi`/`strtol` for unsigned integer + parsing in manifest files. + ([internal MR 4258](https://gitlab.khronos.org/openxr/openxr/merge_requests/4258)) + - Loader: Fix: Fix wrong VUID in empty application name error message. + ([internal MR 4262](https://gitlab.khronos.org/openxr/openxr/merge_requests/4262)) + - Loader: Fix: `stack-use-after-scope` problem in `manifest_file.cpp`. (included + in 1.1.59.1 hotfix as well) + ([internal MR 4295](https://gitlab.khronos.org/openxr/openxr/merge_requests/4295), + [internal MR 2743](https://gitlab.khronos.org/openxr/openxr/merge_requests/2743)) + - Validation Layer: Fix: Verify downstream extension function support before + returning layer wrapper. + ([internal MR 4306](https://gitlab.khronos.org/openxr/openxr/merge_requests/4306)) + - Validation Layer: Fix: Return `xrCreateApiLayerInstance` errors immediately. + ([internal MR 4306](https://gitlab.khronos.org/openxr/openxr/merge_requests/4306)) + - Validation Layer: Fix: Return warning rather than error for unknown enum values + so the runtime can return the correct error code. + ([internal MR 4306](https://gitlab.khronos.org/openxr/openxr/merge_requests/4306)) + - Validation Layer: Fix: Skip enum validation for + `xrResultToString`/`xrStructureTypeToString` since these functions accept any + value by design. + ([internal MR 4306](https://gitlab.khronos.org/openxr/openxr/merge_requests/4306)) + - Validation Layer: Fix: Skip `strlen()` on non-const output char arrays to avoid + undefined behavior on uninitialized buffers. + ([internal MR 4306](https://gitlab.khronos.org/openxr/openxr/merge_requests/4306)) + - Validation Layer: Fix: Destroy implicitly-created debug utils messengers during + instance teardown to prevent handle leaks. + ([internal MR 4306](https://gitlab.khronos.org/openxr/openxr/merge_requests/4306)) +- Registry + - New multi-vendor extension: `XR_EXT_haptic_parametric` + ([internal MR 3307](https://gitlab.khronos.org/openxr/openxr/merge_requests/3307)) + - Change: Deprecate HoloLens 2 related extensions. + ([internal MR 4133](https://gitlab.khronos.org/openxr/openxr/merge_requests/4133)) + - Change: Mark `XR_ANDROID_trackables` and its child extensions as deprecated by + various `XR_EXT` and `XR_ANDROID` spatial entity extensions. + ([internal MR 4228](https://gitlab.khronos.org/openxr/openxr/merge_requests/4228)) + - Fix: Add comment for enum value `XR_SPACE_COMPONENT_TYPE_ROOM_MESH_META` in + `xr.xml`. + ([internal MR 4292](https://gitlab.khronos.org/openxr/openxr/merge_requests/4292), + [internal issue 2740](https://gitlab.khronos.org/openxr/openxr/issues/2740)) + - Fix: Add comment for result value + `XR_BOUNDARY_VISIBILITY_SUPPRESSION_NOT_ALLOWED_META` in `xr.xml`. + ([internal MR 4293](https://gitlab.khronos.org/openxr/openxr/merge_requests/4293), + [internal issue 2739](https://gitlab.khronos.org/openxr/openxr/issues/2739)) + - Fix: Mark `XrSessionCreateInfoOverlayEXTX::createFlags` as optional. + ([internal MR 4302](https://gitlab.khronos.org/openxr/openxr/merge_requests/4302)) + - Fix: Update `XrFoveationEyeTrackedProfileCreateInfoMETA` to mark `flags` as + optional + ([internal MR 4317](https://gitlab.khronos.org/openxr/openxr/merge_requests/4317), + [internal MR 4317](https://gitlab.khronos.org/openxr/openxr/merge_requests/4317)) + - Improvement: Add schematron validation for `optional` required for empty bit + flags. + ([internal MR 4317](https://gitlab.khronos.org/openxr/openxr/merge_requests/4317), + [internal issue 2745](https://gitlab.khronos.org/openxr/openxr/issues/2745)) + - Scripts: Handle deprecation expressions referring to multiple extensions. + ([internal MR 4228](https://gitlab.khronos.org/openxr/openxr/merge_requests/4228)) + +## OpenXR SDK 1.1.59 (2026-04-30) + +This release includes several fixes and cleanups in the loader and various API +layers. There is also an additional multi-vendor extension and vendor extensions +added to the registry with this release. + +- SDK + - Best Practices Layer: Fix: Addresses race conditions + ([internal MR 4208](https://gitlab.khronos.org/openxr/openxr/merge_requests/4208), + [internal issue 2676](https://gitlab.khronos.org/openxr/openxr/issues/2676), + [OpenXR-SDK-Source issue 581](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/581)) + - Loader: Improvement: Code cleanup and robustness improvements. + ([internal MR 3475](https://gitlab.khronos.org/openxr/openxr/merge_requests/3475), + [OpenXR-SDK-Source PR 413](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/413)) + - Loader: Improvement: Use `std::make_unique` instead of raw `new` where + constructors are public. + ([internal MR 4252](https://gitlab.khronos.org/openxr/openxr/merge_requests/4252)) + - Test Runtime: Fix: Address missing directory error when building on macOS. + ([internal MR 4269](https://gitlab.khronos.org/openxr/openxr/merge_requests/4269)) + - Validation Layer: Fix: Cast flags to `uint64_t` before printing as hexadecimal. + ([internal MR 4225](https://gitlab.khronos.org/openxr/openxr/merge_requests/4225)) +- Registry + - Chore: Reserve extension numbers and adjust previous reservations. + ([internal MR 4266](https://gitlab.khronos.org/openxr/openxr/merge_requests/4266), + [internal MR 4276](https://gitlab.khronos.org/openxr/openxr/merge_requests/4276), + [internal MR 4282](https://gitlab.khronos.org/openxr/openxr/merge_requests/4282), + [internal MR 4253](https://gitlab.khronos.org/openxr/openxr/merge_requests/4253)) + - Improvement: Enforce that essentially all functions must be able to return + `XR_ERROR_RUNTIME_FAILURE`. + ([internal MR 3611](https://gitlab.khronos.org/openxr/openxr/merge_requests/3611), + [internal issue 2345](https://gitlab.khronos.org/openxr/openxr/issues/2345)) + - New multi-vendor extension: `XR_EXT_stationary_reference_space` + ([internal MR 3021](https://gitlab.khronos.org/openxr/openxr/merge_requests/3021)) + - New vendor extension: `XR_META_boundary_visibility` + ([internal MR 3249](https://gitlab.khronos.org/openxr/openxr/merge_requests/3249)) + - New vendor extension: `XR_META_face_tracking_visemes` + ([internal MR 3424](https://gitlab.khronos.org/openxr/openxr/merge_requests/3424)) + - New vendor extension: `XR_META_spatial_entity_room_mesh` + ([internal MR 3530](https://gitlab.khronos.org/openxr/openxr/merge_requests/3530)) + - New vendor extension: `XR_ANDROID_eye_tracking` + ([internal MR 3773](https://gitlab.khronos.org/openxr/openxr/merge_requests/3773)) + - New vendor extension: `XR_ANDROID_recommended_resolution` + ([internal MR 3840](https://gitlab.khronos.org/openxr/openxr/merge_requests/3840)) + - New vendor extension: `XR_ANDROID_light_estimation`. + ([internal MR 3879](https://gitlab.khronos.org/openxr/openxr/merge_requests/3879)) + - Schematron: Improvement: Add validation for ordering of structs in `xr.xml`. + ([internal MR 4251](https://gitlab.khronos.org/openxr/openxr/merge_requests/4251)) + - Schematron: Bump schXslt Schematron checker version and fix error in wrapper + script. + ([internal MR 4288](https://gitlab.khronos.org/openxr/openxr/merge_requests/4288)) + - Update vendor specification: Revision 5 of `XR_FB_passthrough` + ([internal MR 3862](https://gitlab.khronos.org/openxr/openxr/merge_requests/3862)) + +## OpenXR SDK 1.1.58 (2026-03-31) + +This release features several fixes to the SDK as well as tooling improvements. +Among the several added extensions, the most notable are the two new ratified +multi-vendor extensions, `XR_EXT_view_configuration_views_change` and +`XR_EXT_interaction_profile_battery_state_display`. + +- SDK + - API Dump Layer: Fix: crash when encountering `XR_TYPE_UNKNOWN` in `next` chain + ([internal MR 4090](https://gitlab.khronos.org/openxr/openxr/merge_requests/4090)) + - Improvement: Enable `-Werror=missing-prototypes` more widely. + ([internal MR 4120](https://gitlab.khronos.org/openxr/openxr/merge_requests/4120)) + - Improvement: Search using QUIET mode for sanitizers, as they are a developer + feature. + ([OpenXR-SDK-Source PR 577](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/577)) + - hello_xr: Improvement: Simplify options parsing + ([internal MR 4155](https://gitlab.khronos.org/openxr/openxr/merge_requests/4155), + [internal MR 3369](https://gitlab.khronos.org/openxr/openxr/merge_requests/3369)) + - hello_xr: Fix: Remove error condition check if `hello_xr` is run with + `XR_VIEW_CONFIGURATION_TYPE_PRIMARY_MONO`. + ([internal MR 4197](https://gitlab.khronos.org/openxr/openxr/merge_requests/4197), + [internal issue 2679](https://gitlab.khronos.org/openxr/openxr/issues/2679)) + - hello_xr: Fix: crash with D3D11 when the runtime does not support an + appropriate depth format. + ([internal MR 4199](https://gitlab.khronos.org/openxr/openxr/merge_requests/4199), + [internal issue 2689](https://gitlab.khronos.org/openxr/openxr/issues/2689), + [OpenXR-SDK-Source issue 589](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/589)) + - hello_xr: Fix: Missed parts of backporting changes from CTS for depth image + support. + ([OpenXR-SDK-Source PR 587](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/587), + [internal issue 2780](https://gitlab.khronos.org/openxr/openxr/issues/2780)) + - hello_xr: Fix: Correct type enum error in D3D12 code. + ([OpenXR-SDK-Source PR 587](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/587), + [internal issue 2780](https://gitlab.khronos.org/openxr/openxr/issues/2780)) + - hello_xr: Improvement: Remove now-unused code in D3D11, OpenGL, and OpenGL ES + backends. + ([OpenXR-SDK-Source PR 587](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/587), + [internal issue 2780](https://gitlab.khronos.org/openxr/openxr/issues/2780)) + - loader_test: Fix: Android compatibility + ([internal MR 4090](https://gitlab.khronos.org/openxr/openxr/merge_requests/4090)) + - loader_test: Improvement: run `loader_test` through CTest on Linux + ([internal MR 4090](https://gitlab.khronos.org/openxr/openxr/merge_requests/4090)) + - test_runtime: Improvement: Simplify session state implementation in + `runtime_test.cpp` + ([internal MR 4159](https://gitlab.khronos.org/openxr/openxr/merge_requests/4159)) + - test_runtime: Fix: Update for marking of `XR_FB_touch_controller_proximity` as + obsoleted by OpenXR 1.1. + ([internal MR 4191](https://gitlab.khronos.org/openxr/openxr/merge_requests/4191), + [internal issue 2599](https://gitlab.khronos.org/openxr/openxr/issues/2599)) + - test_runtime: Improvement: Fix quaternion validation percentage in + `runtime_test.cpp` + ([internal MR 4192](https://gitlab.khronos.org/openxr/openxr/merge_requests/4192), + [internal MR 4159](https://gitlab.khronos.org/openxr/openxr/merge_requests/4159)) +- Registry + - Change: Mark `XR_FB_space_warp` as deprecated by `XR_EXT_frame_synthesis`, + which provides the same functionality with a slightly modified interface. + ([internal MR 4173](https://gitlab.khronos.org/openxr/openxr/merge_requests/4173), + [internal issue 2469](https://gitlab.khronos.org/openxr/openxr/issues/2469)) + - Chore: Reserve extension numbers. + ([internal MR 4204](https://gitlab.khronos.org/openxr/openxr/merge_requests/4204)) + - Fix: Mark `XR_FB_touch_controller_proximity` as obsoleted by OpenXR 1.1. + ([internal MR 4191](https://gitlab.khronos.org/openxr/openxr/merge_requests/4191), + [internal issue 2599](https://gitlab.khronos.org/openxr/openxr/issues/2599)) + - Improvement: Add command return code checks in `xml_consistency.py` for + specific spatial entity input types. + ([internal MR 4151](https://gitlab.khronos.org/openxr/openxr/merge_requests/4151)) + - New ratified multi-vendor extension: `XR_EXT_view_configuration_views_change` + ([internal MR 711](https://gitlab.khronos.org/openxr/openxr/merge_requests/711), + [internal issue 619](https://gitlab.khronos.org/openxr/openxr/issues/619)) + - New ratified multi-vendor extension: + `XR_EXT_interaction_profile_battery_state_display`. + ([internal MR 3528](https://gitlab.khronos.org/openxr/openxr/merge_requests/3528), + [internal issue 1339](https://gitlab.khronos.org/openxr/openxr/issues/1339), + [internal issue 1905](https://gitlab.khronos.org/openxr/openxr/issues/1905)) + - New vendor extension: `XR_QCOM_hand_tracking_gesture` + ([internal MR 2572](https://gitlab.khronos.org/openxr/openxr/merge_requests/2572)) + - New vendor extension: `XR_META_body_tracking_fidelity` + ([internal MR 2962](https://gitlab.khronos.org/openxr/openxr/merge_requests/2962)) + - New vendor extension: `XR_META_spatial_entity_semantic_label` + ([internal MR 3529](https://gitlab.khronos.org/openxr/openxr/merge_requests/3529)) + - New vendor extension: `XR_ANDROID_performance_metrics` + ([internal MR 3607](https://gitlab.khronos.org/openxr/openxr/merge_requests/3607)) + - New vendor extension: `XR_ANDROID_mouse_interaction` + ([internal MR 3608](https://gitlab.khronos.org/openxr/openxr/merge_requests/3608)) + - New vendor extension: `XR_ANDROID_unbounded_reference_space` + ([internal MR 3624](https://gitlab.khronos.org/openxr/openxr/merge_requests/3624)) + - New vendor extension: `XR_ANDROID_composition_layer_passthrough_mesh` + ([internal MR 3625](https://gitlab.khronos.org/openxr/openxr/merge_requests/3625)) + - New vendor extension: `XR_META_environment_raycast` + ([internal MR 3758](https://gitlab.khronos.org/openxr/openxr/merge_requests/3758)) + - New vendor extension: `XR_ANDROID_trackables_qr_code` + ([internal MR 3772](https://gitlab.khronos.org/openxr/openxr/merge_requests/3772)) + - New vendor extension: `XR_BD_spatial_audio_rendering` + ([internal MR 3794](https://gitlab.khronos.org/openxr/openxr/merge_requests/3794)) + - New vendor extension: `XR_ANDROID_scene_meshing` + ([internal MR 3872](https://gitlab.khronos.org/openxr/openxr/merge_requests/3872)) + - New vendor extension: `XR_META_tile_properties_hint` + ([internal MR 3885](https://gitlab.khronos.org/openxr/openxr/merge_requests/3885)) + - New vendor extension: `XR_ANDROID_spatial_object_tracking` + ([internal MR 3992](https://gitlab.khronos.org/openxr/openxr/merge_requests/3992)) + - New vendor extension: `XR_ANDROID_spatial_discovery_raycast` + ([internal MR 3993](https://gitlab.khronos.org/openxr/openxr/merge_requests/3993)) + - New vendor extension: `XR_ANDROID_spatial_entity_bound_anchor` + ([internal MR 3994](https://gitlab.khronos.org/openxr/openxr/merge_requests/3994)) + - New vendor extension: `XR_ANDROID_spatial_component_subsumed_by` + ([internal MR 4125](https://gitlab.khronos.org/openxr/openxr/merge_requests/4125)) + - New vendor extension: `XR_ANDROID_spatial_anchor_space` + ([internal MR 4132](https://gitlab.khronos.org/openxr/openxr/merge_requests/4132)) + - Schematron: Add schematron validation for prefix `XrCompositionLayer` for + structures which extend `XrCompositionLayerBaseHeader`. + ([internal MR 4131](https://gitlab.khronos.org/openxr/openxr/merge_requests/4131)) + +## OpenXR SDK 1.1.57 (2026-02-12) + +This release primarily features several fixes to the SDK as well as tooling +improvements. + +Note that specification releases 1.1.55 and 1.1.56 were skipped to keep up with +a monthly increment for the patch version component. + +- SDK + - Fix: Do not attempt to install manpages on Android, and ensure all directory + prefixes are populated, fixing CMake install. + ([OpenXR-SDK-Source PR 573](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/573), + [OpenXR-SDK-Source issue 568](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/568), + [internal issue 2645](https://gitlab.khronos.org/openxr/openxr/issues/2645)) + - Loader: Reduce severity of Android loader "broker not found" messages from + error to warning. + ([internal MR 4134](https://gitlab.khronos.org/openxr/openxr/merge_requests/4134)) + - Validation Layer: Fix core validation layer validation of `xrCreateSession` to + support `XR_TYPE_GRAPHICS_BINDING_METAL_KHR` and + `XR_TYPE_GRAPHICS_BINDING_EGL_MNDX`. + ([internal MR 4119](https://gitlab.khronos.org/openxr/openxr/merge_requests/4119), + [internal issue 2646](https://gitlab.khronos.org/openxr/openxr/issues/2646)) + - hello_xr: Deduplicate code in internal "gfxwrapper" library used in hello_xr + (among other uses) for OpenGL/OpenGL ES. Add an explicit always-EGL path. + ([internal MR 2942](https://gitlab.khronos.org/openxr/openxr/merge_requests/2942), + [internal issue 1911](https://gitlab.khronos.org/openxr/openxr/issues/1911)) + - hello_xr: Fix out of bounds read when none of the required depth formats is + supported. + ([internal MR 4145](https://gitlab.khronos.org/openxr/openxr/merge_requests/4145), + [OpenXR-SDK-Source issue 578](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/578), + [internal issue 2663](https://gitlab.khronos.org/openxr/openxr/issues/2663), + [internal MR 4023](https://gitlab.khronos.org/openxr/openxr/merge_requests/4023)) + - loader_test: Update Catch2 test library from 3.7.1 to 3.11.0. + ([internal MR 4006](https://gitlab.khronos.org/openxr/openxr/merge_requests/4006), + [internal issue 2108](https://gitlab.khronos.org/openxr/openxr/issues/2108)) +- Registry + - Change: Update tooling to properly support extending allowable return codes + from extensions. + ([internal MR 4009](https://gitlab.khronos.org/openxr/openxr/merge_requests/4009), + [internal issue 2494](https://gitlab.khronos.org/openxr/openxr/issues/2494)) + - Chore: Reorder function return codes to alphabetic (with `XR_SUCCESS` pulled to + the front). + ([internal MR 3979](https://gitlab.khronos.org/openxr/openxr/merge_requests/3979)) + - Chore: Reserve extensions. + ([internal MR 4157](https://gitlab.khronos.org/openxr/openxr/merge_requests/4157), + [internal MR 4162](https://gitlab.khronos.org/openxr/openxr/merge_requests/4162)) + - Fix: `XR_KHR_extended_struct_name_lengths` string length can be up to 256 + bytes. (The prose has been modified to match the XML specification.) + ([internal MR 4126](https://gitlab.khronos.org/openxr/openxr/merge_requests/4126), + [internal issue 2654](https://gitlab.khronos.org/openxr/openxr/issues/2654)) + - New vendor extension: `XR_ANDROID_trackables_image`. + ([internal MR 4069](https://gitlab.khronos.org/openxr/openxr/merge_requests/4069)) + - Schematron: Add validation for return code ordering. + ([internal MR 3979](https://gitlab.khronos.org/openxr/openxr/merge_requests/3979)) + - Schematron: Add validation for semantic label enums defined for the spatial + entity framework. + ([internal MR 4081](https://gitlab.khronos.org/openxr/openxr/merge_requests/4081)) + - Update: Mark `XR_EXT_plane_detection` as deprecated by + `XR_EXT_spatial_plane_tracking`. + ([internal MR 4057](https://gitlab.khronos.org/openxr/openxr/merge_requests/4057), + [internal issue 2625](https://gitlab.khronos.org/openxr/openxr/issues/2625)) + +## OpenXR SDK 1.1.54 (2025-12-02) + +This release updates the C++ standards version used by the package, and includes +changes to hello_xr to bring it closer in line with the OpenXR-CTS (which come +from a shared codebase) and allow optional submission of depth textures where +supported, among other changes. + +- SDK + - Change: Update C++ standard version used from C++14 to C++17. + ([internal MR 4096](https://gitlab.khronos.org/openxr/openxr/merge_requests/4096)) + - Chore: Add extra compiler validation for the OpenXR loader. + ([internal MR 4086](https://gitlab.khronos.org/openxr/openxr/merge_requests/4086)) + - Chore: Fix -Wmissing-prototypes compiler warnings. + ([internal MR 4107](https://gitlab.khronos.org/openxr/openxr/merge_requests/4107)) + - Improvement: Add build option `INSTALL_SYMBOLS` (enabled by default to maintain + current behavior), to allow skipping installing `.PDB` files from MSVC builds. + ([internal MR 4066](https://gitlab.khronos.org/openxr/openxr/merge_requests/4066), + [internal issue 2634](https://gitlab.khronos.org/openxr/openxr/issues/2634)) + - Improvement: Clarify loader doc regarding removed permission requirement for + installable broker. + ([internal MR 4092](https://gitlab.khronos.org/openxr/openxr/merge_requests/4092)) + - Validation Layer: Fix the `library_path` of + `XrApiLayer_best_practices_validation.json` on Windows + ([internal MR 4080](https://gitlab.khronos.org/openxr/openxr/merge_requests/4080), + [internal issue 2629](https://gitlab.khronos.org/openxr/openxr/issues/2629)) + - hello_xr: Revise rendering to be more similar to the CTS, and add optional + support for `XR_KHR_composition_layer_depth`. + ([internal MR 4023](https://gitlab.khronos.org/openxr/openxr/merge_requests/4023), + [internal MR 4118](https://gitlab.khronos.org/openxr/openxr/merge_requests/4118), + [internal MR 4121](https://gitlab.khronos.org/openxr/openxr/merge_requests/4121)) +- Registry + - Change: Deprecate the Wayland part of `XR_KHR_opengl_enable` and bump version. + ([internal MR 4052](https://gitlab.khronos.org/openxr/openxr/merge_requests/4052), + [OpenXR-SDK-Source issue 282](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/282), + [internal issue 1634](https://gitlab.khronos.org/openxr/openxr/issues/1634), + [internal issue 2559](https://gitlab.khronos.org/openxr/openxr/issues/2559)) + - Chore: Reserve extensions. + ([internal MR 4067](https://gitlab.khronos.org/openxr/openxr/merge_requests/4067), + [internal MR 4079](https://gitlab.khronos.org/openxr/openxr/merge_requests/4079), + [internal MR 4098](https://gitlab.khronos.org/openxr/openxr/merge_requests/4098), + [internal MR 4099](https://gitlab.khronos.org/openxr/openxr/merge_requests/4099), + [internal MR 4100](https://gitlab.khronos.org/openxr/openxr/merge_requests/4100)) + - Fix: Correctly define `XR_EXT_dpad_binding` paths for + /interaction_profiles/bytedance/pico_ultra_controller_bd in XML. + ([internal MR 4049](https://gitlab.khronos.org/openxr/openxr/merge_requests/4049)) + - Improvement: Add description for `XR_SPACE_COMPONENT_TYPE_TRIANGLE_MESH_META`. + ([internal MR 4070](https://gitlab.khronos.org/openxr/openxr/merge_requests/4070)) + - Schematron: Add validation to ensure bitmasks are non-plural before + `Flags`/`FlagBits`. + ([internal MR 2678](https://gitlab.khronos.org/openxr/openxr/merge_requests/2678)) + - Schematron: Add validation to check additional scenarios of `next` pointer + const-ness. + ([internal MR 2740](https://gitlab.khronos.org/openxr/openxr/merge_requests/2740)) + - Schematron: Add validation for interaction profile extension binding additions. + ([internal MR 3982](https://gitlab.khronos.org/openxr/openxr/merge_requests/3982)) + - Schematron: Remove unneeded exception from "Param/member naming conventions: + camelCase" pattern. + ([internal MR 4072](https://gitlab.khronos.org/openxr/openxr/merge_requests/4072)) + - Schematron: Fix check for multiple arrays bounded by the same `len` param. + ([internal MR 4077](https://gitlab.khronos.org/openxr/openxr/merge_requests/4077)) + - Schematron: Add validation for the comment attribute of + `XrSpatialComponentTypeEXT` values. The comment must reference the list and + data structs for the component. + ([internal MR 4083](https://gitlab.khronos.org/openxr/openxr/merge_requests/4083)) + - Schematron: Add validation for the comment attribute of + `XrSpatialCapabilityFeatureEXT` values. The comment must have references to the + feature's config structs. + ([internal MR 4084](https://gitlab.khronos.org/openxr/openxr/merge_requests/4084)) + - Schematron: Add check for orphaned structs, enforcing `structextends` or + `parentstruct` when appropriate. + ([internal MR 4091](https://gitlab.khronos.org/openxr/openxr/merge_requests/4091), + [internal MR 4094](https://gitlab.khronos.org/openxr/openxr/merge_requests/4094)) + - Update: Bump XR_EXT_future version due to clarifying what the runtime may do in + a completion function of an `XrFutureEXT`. + ([internal MR 3796](https://gitlab.khronos.org/openxr/openxr/merge_requests/3796), + [internal MR 4028](https://gitlab.khronos.org/openxr/openxr/merge_requests/4028)) + - Update: Add `XrEnvironmentDepthImageTimestampMETA` to + XR_META_environment_depth, update spec version to 2. + ([internal MR 4024](https://gitlab.khronos.org/openxr/openxr/merge_requests/4024)) + +## OpenXR SDK 1.1.53 (2025-10-14) + +This release contains three new vendor extensions and some code cleanups. The +test_runtime expansion is primarily intended for CTS self-testing but may be +useful in other development processes as well. + +- SDK + - Improvement: fix clang-tidy bugprone-branch-clone warning + ([internal MR 3864](https://gitlab.khronos.org/openxr/openxr/merge_requests/3864), + [internal MR 4027](https://gitlab.khronos.org/openxr/openxr/merge_requests/4027)) + - Improvement: Expand the "test_runtime" to implement all OpenXR 1.0 / OpenXR 1.1 + functions for self-test purposes. + ([internal MR 3989](https://gitlab.khronos.org/openxr/openxr/merge_requests/3989)) + - Improvement: Add stricter compiler flags to the loader and hello_xr, fixing + issues found. + ([internal MR 4028](https://gitlab.khronos.org/openxr/openxr/merge_requests/4028), + [internal MR 4042](https://gitlab.khronos.org/openxr/openxr/merge_requests/4042)) + - Loader: Fix: Remove unused function definition `xrInitializeLoaderKHR` to fix + pedantic builds. + ([internal MR 4020](https://gitlab.khronos.org/openxr/openxr/merge_requests/4020)) +- Registry + - Fix: Bump `XR_ANDROID_trackables_object` version for fix to orientation. + ([internal MR 4018](https://gitlab.khronos.org/openxr/openxr/merge_requests/4018)) + - New vendor extension: `XR_BD_facial_simulation` for vendor-specific access to + facial expressions. + ([internal MR 2925](https://gitlab.khronos.org/openxr/openxr/merge_requests/2925)) + - New vendor extension: `XR_BD_ultra_controller_interaction` for PICO Ultra + controller interaction profile. + ([internal MR 3789](https://gitlab.khronos.org/openxr/openxr/merge_requests/3789)) + - New vendor extension specification: `XR_ANDROID_face_tracking` for vendor- + specific access to facial expressions. + ([internal MR 3613](https://gitlab.khronos.org/openxr/openxr/merge_requests/3613)) + - Update: Bump version of `XR_MND_headless` for clarification. + ([internal MR 3961](https://gitlab.khronos.org/openxr/openxr/merge_requests/3961)) + +## OpenXR SDK 1.1.52 (2025-09-19) + +This release contains a new ratified Khronos extension, a new vendor extension, +fixes for issues in the XML registry, and API layer improvements. + +- SDK + - Improvement: Adjust the enabled clang-tidy checks after resolving some minor + identified warnings. + ([internal MR 3898](https://gitlab.khronos.org/openxr/openxr/merge_requests/3898)) + - Layers: Fix: Skip checking members other than `type` and `next` on structs + marked `returnedonly="true"` in core validation layer. + ([internal MR 3973](https://gitlab.khronos.org/openxr/openxr/merge_requests/3973)) + - Layers: Fix: Rename `KHR_best_practices_validation` -> + `KHRONOS_best_practices_validation` + ([internal MR 3984](https://gitlab.khronos.org/openxr/openxr/merge_requests/3984)) + - Loader: Improvement: Further clean up defines related to XR_KHR_loader_init. + ([internal MR 3937](https://gitlab.khronos.org/openxr/openxr/merge_requests/3937), + [internal MR 3948](https://gitlab.khronos.org/openxr/openxr/merge_requests/3948)) +- Registry + - New ratified Khronos extension: `XR_KHR_generic_controller` + ([internal MR 3018](https://gitlab.khronos.org/openxr/openxr/merge_requests/3018)) + - Update: Ratified `XR_EXT_debug_utils` + ([internal MR 3899](https://gitlab.khronos.org/openxr/openxr/merge_requests/3899)) + - Update: Ratified `XR_EXT_render_model` + ([internal MR 3900](https://gitlab.khronos.org/openxr/openxr/merge_requests/3900)) + - Update: Ratified `XR_EXT_interaction_render_model` + ([internal MR 3901](https://gitlab.khronos.org/openxr/openxr/merge_requests/3901)) + - New vendor extension: `XR_META_spatial_entity_discovery`. + ([internal MR 2880](https://gitlab.khronos.org/openxr/openxr/merge_requests/2880), + [internal MR 4001](https://gitlab.khronos.org/openxr/openxr/merge_requests/4001)) + - Change: Revert `XrTrackablePlaneANDROID::vertexCountOutput` to a pointer, and + increment extension version number. + ([internal MR 3998](https://gitlab.khronos.org/openxr/openxr/merge_requests/3998)) + - Chore: Reserve numbers for extensions. + ([internal MR 4004](https://gitlab.khronos.org/openxr/openxr/merge_requests/4004)) + - Fix: Add XML for missing `grip_surface` paths for + "/interaction_profiles/ext/hand_interaction_ext". Note that these paths were + already listed in the spec prose. Update `XR_EXT_hand_interaction` extension + version to `2` for clarity. + ([internal MR 3963](https://gitlab.khronos.org/openxr/openxr/merge_requests/3963)) + - Fix: Mark a few structure members that are bitmasks as optional, to match prose + and/or usage intent. + ([internal MR 3973](https://gitlab.khronos.org/openxr/openxr/merge_requests/3973)) + - Fix: Mark `XrCompositionLayerPassthroughFB.space` as optional to match spec + prose. + ([internal MR 3973](https://gitlab.khronos.org/openxr/openxr/merge_requests/3973)) + - Fix: Add XML for missing `palm_ext/pose` and `grip_surface/pose` paths for + "/interaction_profiles/logitech/mx_ink_stylus_logitech". Note that these paths + were already listed in the spec prose. + ([internal MR 3996](https://gitlab.khronos.org/openxr/openxr/merge_requests/3996)) + +## OpenXR SDK 1.1.51 (2025-08-28) + +This release adds a new API layer to assist developers in making an OpenXR +application that follows best practices, along with a number of miscellaneous +other fixes and improvements. + +- SDK + - Added: New "best practices validation" API layer to check for application + behavior that is valid but contradicts best practices. + ([internal MR 3735](https://gitlab.khronos.org/openxr/openxr/merge_requests/3735), + [internal MR 3976](https://gitlab.khronos.org/openxr/openxr/merge_requests/3976)) + - Fix: Include command alias in `XR_LIST_FUNCTION_` macros in + `openxr_reflection.h`. + ([internal MR 3915](https://gitlab.khronos.org/openxr/openxr/merge_requests/3915), + [internal issue 2222](https://gitlab.khronos.org/openxr/openxr/issues/2222)) + - Fix: Consistent usage of `XR_KHR_LOADER_INIT_SUPPORT` defines. + ([internal MR 3936](https://gitlab.khronos.org/openxr/openxr/merge_requests/3936)) + - Fix: Migrate scripts to publish Android OpenXR loader AAR to Maven Central via + new process. + ([internal MR 3978](https://gitlab.khronos.org/openxr/openxr/merge_requests/3978), + [internal issue 2499](https://gitlab.khronos.org/openxr/openxr/issues/2499), + [internal MR 3975](https://gitlab.khronos.org/openxr/openxr/merge_requests/3975)) + - Improvement: enable clang-tidy bugprone-unused-local-non-trivial-variable + check. + ([internal MR 3892](https://gitlab.khronos.org/openxr/openxr/merge_requests/3892)) + - Improvement: Fixed unused parameters in gfxwrapper. + ([internal MR 3894](https://gitlab.khronos.org/openxr/openxr/merge_requests/3894)) + - Improvement: Provide more useful metadata in the Android OpenXR loader AAR POM + file. + ([internal MR 3978](https://gitlab.khronos.org/openxr/openxr/merge_requests/3978), + [internal issue 2499](https://gitlab.khronos.org/openxr/openxr/issues/2499), + [internal MR 3975](https://gitlab.khronos.org/openxr/openxr/merge_requests/3975)) + - hello_xr: Fix Vulkan resource destruction bugs of ShaderProgram and Pipeline. + ([OpenXR-SDK-Source PR 538](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/538)) +- Registry + - Chore: Reserve extension numbers. + ([internal MR 3916](https://gitlab.khronos.org/openxr/openxr/merge_requests/3916), + [internal MR 3956](https://gitlab.khronos.org/openxr/openxr/merge_requests/3956)) + - Fix: Missing parent struct for `XrSpatialCapabilityConfigurationAnchorEXT`. + ([internal MR 3932](https://gitlab.khronos.org/openxr/openxr/merge_requests/3932)) + - Fix: Missing `XR_EXT_dpad_binding` paths for + `/interaction_profiles/facebook/touch_controller_pro` and + `/interaction_profiles/meta/touch_controller_plus`. + ([internal MR 3945](https://gitlab.khronos.org/openxr/openxr/merge_requests/3945)) + - Fix: incorrect placement of `*` in + `XR_ERROR_GRAPHICS_REQUIREMENTS_CALL_MISSING` error description. + ([internal MR 3960](https://gitlab.khronos.org/openxr/openxr/merge_requests/3960)) + - Fix: Missing `XR_EXT_dpad_binding` paths for + `/interaction_profiles/varjo/xr-4_controller`. + ([internal MR 3965](https://gitlab.khronos.org/openxr/openxr/merge_requests/3965)) + - Fix: Missing `XR_EXT_dpad_binding`, `XR_EXT_palm_pose`, and + `XR_EXT_hand_interaction` bindings for + `/interaction_profiles/oppo/mr_controller_oppo`. + ([internal MR 3966](https://gitlab.khronos.org/openxr/openxr/merge_requests/3966)) + +## OpenXR SDK 1.1.50 (2025-07-24) + +This release features a new loader extension for some specific automation use +cases, several new vendor extensions, and code quality improvements, among other +changes. + +- SDK + - Fix: Revise how OpenGL compatibility is detected in the build system on + Windows. + ([internal MR 3883](https://gitlab.khronos.org/openxr/openxr/merge_requests/3883)) + - Fix: Add missing include directive in loader code. + ([OpenXR-SDK-Source PR 554](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/554)) + - Improvement: Add support for sanitizers in CMake with sanitizers-cmake project. + ([internal MR 3716](https://gitlab.khronos.org/openxr/openxr/merge_requests/3716)) + - Improvement: add `.clang-tidy` file. + ([internal MR 3802](https://gitlab.khronos.org/openxr/openxr/merge_requests/3802)) + - Improvement: Enable the clang-tidy cert-dcl16-c, bugprone-too-small-loop- + variable, and bugprone-switch-missing-default-case checks, making fixes + required to satisfy them. + ([internal MR 3882](https://gitlab.khronos.org/openxr/openxr/merge_requests/3882), + [internal MR 3893](https://gitlab.khronos.org/openxr/openxr/merge_requests/3893)) + - Improvement: Disable the clang-tidy bugprone-reserved-identifier, cert-dcl37-c, + and cert-dcl51-cpp checks. + ([internal MR 3882](https://gitlab.khronos.org/openxr/openxr/merge_requests/3882), + [internal MR 3893](https://gitlab.khronos.org/openxr/openxr/merge_requests/3893)) + - Loader: Implement `XR_EXT_loader_init_properties` extension and enable + `XR_KHR_loader_init` on all platforms. + ([internal MR 2454](https://gitlab.khronos.org/openxr/openxr/merge_requests/2454)) + - Loader: Refactor loader data class and handling, preparing for loader data + properties. + ([internal MR 3834](https://gitlab.khronos.org/openxr/openxr/merge_requests/3834), + [internal MR 3839](https://gitlab.khronos.org/openxr/openxr/merge_requests/3839)) + - Loader: Ensure that only the first Android property is used. + ([internal MR 3834](https://gitlab.khronos.org/openxr/openxr/merge_requests/3834), + [internal MR 3839](https://gitlab.khronos.org/openxr/openxr/merge_requests/3839)) + - Scripts: Handle the case where "current_ref_page" is a string rather than an + object. + ([internal MR 3834](https://gitlab.khronos.org/openxr/openxr/merge_requests/3834), + [internal MR 3839](https://gitlab.khronos.org/openxr/openxr/merge_requests/3839)) + - Validation Layer: Accept unknown or duplicated structure types in the `next` + chain, and dump debug messages for them. + ([internal MR 3828](https://gitlab.khronos.org/openxr/openxr/merge_requests/3828)) + - hello_xr: Optimize graphics synchronization when using Vulkan. + ([internal MR 3681](https://gitlab.khronos.org/openxr/openxr/merge_requests/3681)) +- Registry + - Change: Update the `XrSpatialAnchorCreateCompletionBD` structure, and increment + the revision of `XR_BD_spatial_anchor`. + ([internal MR 3876](https://gitlab.khronos.org/openxr/openxr/merge_requests/3876)) + - Fix: Remove `XR_EXT_palm_pose` paths from `XR_HTCX_vive_tracker_interaction`, + as the /user/hand/left|right paths are not valid paths for Vive Trackers. + ([internal MR 3844](https://gitlab.khronos.org/openxr/openxr/merge_requests/3844)) + - Fix: Include `XR_ERROR_SESSION_NOT_RUNNING` in list of errors + `xrEnumerateInteractionRenderModelIdsEXT` can return. (Already in specification + prose.) + ([internal MR 3889](https://gitlab.khronos.org/openxr/openxr/merge_requests/3889)) + - Fix: Typo in comment for `XR_ERROR_SPATIAL_PERSISTENCE_SCOPE_INCOMPATIBLE_EXT`. + ([internal MR 3897](https://gitlab.khronos.org/openxr/openxr/merge_requests/3897)) + - Fix: Add explicit dependency to `XR_ML_compat` for + `XrCoordinateSpaceCreateInfoML`. + ([internal MR 3907](https://gitlab.khronos.org/openxr/openxr/merge_requests/3907)) + - Improvement: Add comments for the `XrResult` values added by + `XR_BD_spatial_anchor` and `XR_BD_spatial_anchor_sharing`. + ([internal MR 3861](https://gitlab.khronos.org/openxr/openxr/merge_requests/3861), + [internal issue 2535](https://gitlab.khronos.org/openxr/openxr/issues/2535)) + - New multi-vendor extension: `XR_EXT_loader_init_properties` + ([internal MR 2454](https://gitlab.khronos.org/openxr/openxr/merge_requests/2454)) + - New vendor extension: `XR_META_body_tracking_calibration`. + ([internal MR 2963](https://gitlab.khronos.org/openxr/openxr/merge_requests/2963)) + - New vendor extension: `XR_ANDROID_passthrough_camera_state`. + ([internal MR 3614](https://gitlab.khronos.org/openxr/openxr/merge_requests/3614)) + - New vendor extension: `XR_ANDROID_trackables`. + ([internal MR 3615](https://gitlab.khronos.org/openxr/openxr/merge_requests/3615)) + - New vendor extension: `XR_ANDROID_raycast`. + ([internal MR 3620](https://gitlab.khronos.org/openxr/openxr/merge_requests/3620)) + - New vendor extension: `XR_ANDROID_trackables_object`. + ([internal MR 3623](https://gitlab.khronos.org/openxr/openxr/merge_requests/3623)) + - New vendor extension: `XR_ANDROID_device_anchor_persistence`. + ([internal MR 3626](https://gitlab.khronos.org/openxr/openxr/merge_requests/3626)) + - New vendor extension: `XR_ANDROID_anchor_sharing_export`. + ([internal MR 3627](https://gitlab.khronos.org/openxr/openxr/merge_requests/3627)) + - New vendor extension: `XR_ANDROID_trackables_marker`. + ([internal MR 3774](https://gitlab.khronos.org/openxr/openxr/merge_requests/3774)) + +## OpenXR SDK 1.1.49 (2025-06-10) + +This release primarily adds new extensions: a collection of ratified +multi-vendor extensions related to "spatial entities", multi-vendor extensions +to work with interaction render models, and a vendor extension. + +- SDK + - Improvement: Fix multiple clang-format formatting issues. + ([internal MR 3845](https://gitlab.khronos.org/openxr/openxr/merge_requests/3845)) + - Validation Layer: Add support for handles created by async operations. + ([internal MR 3030](https://gitlab.khronos.org/openxr/openxr/merge_requests/3030)) +- Registry + - New ratified multi-vendor extension: `XR_EXT_spatial_entity` + ([internal MR 3030](https://gitlab.khronos.org/openxr/openxr/merge_requests/3030), + [internal MR 3874](https://gitlab.khronos.org/openxr/openxr/merge_requests/3874)) + - New ratified multi-vendor extension: `XR_EXT_spatial_anchor` + ([internal MR 3286](https://gitlab.khronos.org/openxr/openxr/merge_requests/3286), + [internal MR 3874](https://gitlab.khronos.org/openxr/openxr/merge_requests/3874)) + - New ratified multi-vendor extension: `XR_EXT_spatial_plane_tracking` + ([internal MR 3402](https://gitlab.khronos.org/openxr/openxr/merge_requests/3402)) + - New ratified multi-vendor extension: `XR_EXT_spatial_marker_tracking` + ([internal MR 3414](https://gitlab.khronos.org/openxr/openxr/merge_requests/3414)) + - New ratified multi-vendor extension: `XR_EXT_spatial_persistence` + ([internal MR 3533](https://gitlab.khronos.org/openxr/openxr/merge_requests/3533), + [internal MR 3874](https://gitlab.khronos.org/openxr/openxr/merge_requests/3874)) + - New ratified multi-vendor extension: `XR_EXT_spatial_persistence_operations` + ([internal MR 3606](https://gitlab.khronos.org/openxr/openxr/merge_requests/3606)) + - New multi-vendor extension: `XR_EXT_render_model` + ([internal MR 2464](https://gitlab.khronos.org/openxr/openxr/merge_requests/2464), + [internal MR 2095](https://gitlab.khronos.org/openxr/openxr/merge_requests/2095), + [internal MR 3225](https://gitlab.khronos.org/openxr/openxr/merge_requests/3225)) + - New multi-vendor extension: `XR_EXT_interaction_render_models` + ([internal MR 2615](https://gitlab.khronos.org/openxr/openxr/merge_requests/2615), + [internal issue 2353](https://gitlab.khronos.org/openxr/openxr/issues/2353), + [internal MR 3551](https://gitlab.khronos.org/openxr/openxr/merge_requests/3551), + [internal MR 3629](https://gitlab.khronos.org/openxr/openxr/merge_requests/3629), + [internal MR 3710](https://gitlab.khronos.org/openxr/openxr/merge_requests/3710)) + - New vendor extension: `XR_BD_spatial_plane` + ([internal MR 3777](https://gitlab.khronos.org/openxr/openxr/merge_requests/3777)) + +## OpenXR SDK 1.1.48 (2025-06-03) + +This release makes a switch to 16KB page sizes for Android, to improve +compatibility of the loader binaries, among other build system adjustments. The +"gfxwrapper" utility used by hello_xr (and the CTS) now uses the widely-used +"GLAD2" wrapper to load OpenGL and related functionality, rather than internal +hand-coded wrappers. + +- SDK + - Improvement: Adapt gfxwrapper to use GLAD2 to load OpenGL, OpenGL ES, and EGL functions. + ([internal MR 3125](https://gitlab.khronos.org/openxr/openxr/merge_requests/3125), + [internal MR 3126](https://gitlab.khronos.org/openxr/openxr/merge_requests/3126)) + - Improvement: Minor loader_test debugging improvements. + ([internal MR 3836](https://gitlab.khronos.org/openxr/openxr/merge_requests/3836)) + - Improvement: Correctly detect availability of OpenGL on less common Windows + platform variants, to fix 32-bit ARM non-UWP builds. + ([internal MR 3838](https://gitlab.khronos.org/openxr/openxr/merge_requests/3838)) + - Improvement: hello_xr: Warning fixes. + ([OpenXR-SDK-Source PR 516](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/516)) + - Improvement: Enable 16KB page sizes when building for Android, required for + targeting Android 15+. + ([OpenXR-SDK-Source PR 548](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/548), + [OpenXR-SDK-Source issue 546](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/546)) +- Registry + - Change: Increment the revision of `XR_BD_spatial_anchor_sharing`. + ([internal MR 3855](https://gitlab.khronos.org/openxr/openxr/merge_requests/3855)) + - Chore: Reserve extension numbers. + ([internal MR 3696](https://gitlab.khronos.org/openxr/openxr/merge_requests/3696), + [internal MR 3797](https://gitlab.khronos.org/openxr/openxr/merge_requests/3797), + [internal MR 3815](https://gitlab.khronos.org/openxr/openxr/merge_requests/3815), + [internal MR 3827](https://gitlab.khronos.org/openxr/openxr/merge_requests/3827)) + - Fix: Explicitly list the "x" and "y" thumbstick components on + "pico_g3_controller" in the XML. + ([internal MR 3851](https://gitlab.khronos.org/openxr/openxr/merge_requests/3851)) + - Increment graphics binding extension revision numbers due to + rephrase/reorganization. + ([internal MR 3028](https://gitlab.khronos.org/openxr/openxr/merge_requests/3028), + [internal MR 3742](https://gitlab.khronos.org/openxr/openxr/merge_requests/3742)) + - New vendor extension: `XR_META_simultaneous_hands_and_controllers` + ([internal MR 2755](https://gitlab.khronos.org/openxr/openxr/merge_requests/2755)) + - New vendor extension: `XR_META_body_tracking_full_body` + ([internal MR 2961](https://gitlab.khronos.org/openxr/openxr/merge_requests/2961)) + - New vendor extension: `XR_BD_future_progress` + ([internal MR 3724](https://gitlab.khronos.org/openxr/openxr/merge_requests/3724)) + +## OpenXR SDK 1.1.47 (2025-04-08) + +This release features several new vendor extensions, one of which required a +modification to the XML schema for extending interaction profiles to represent +accurate. It also contains substantial fixes to the `core_validation` layer to +make it more usable and fix common false-positive validation errors, among other +improvements. + +- Registry + - Addition to XML registry schema: Specify interaction profile additions by + constructing a predicate, and allow adding new top level /user paths to + existing profiles. See SDK changelog and style guide for details. + ([internal MR 2467](https://gitlab.khronos.org/openxr/openxr/merge_requests/2467)) + - Chore: Reserve extension numbers. + ([internal MR 3729](https://gitlab.khronos.org/openxr/openxr/merge_requests/3729), + [internal MR 3744](https://gitlab.khronos.org/openxr/openxr/merge_requests/3744), + [internal MR 3745](https://gitlab.khronos.org/openxr/openxr/merge_requests/3745)) + - Fix: Reflect requirement of `XR_META_hand_tracking_microgestures` for + `XR_EXT_hand_interaction` in `xr.xml`. + ([internal MR 3741](https://gitlab.khronos.org/openxr/openxr/merge_requests/3741)) + - Fix: Added missing comment on `XR_EYE_POSITION_COUNT_FB` to remove warning + during build. + ([internal MR 3748](https://gitlab.khronos.org/openxr/openxr/merge_requests/3748)) + - Fix: typo in the documentation of `XR_ERROR_SPACE_GROUP_NOT_FOUND_META` + ([internal MR 3749](https://gitlab.khronos.org/openxr/openxr/merge_requests/3749)) + - Improvement: Fix schematron runner on Mac. + ([internal MR 3759](https://gitlab.khronos.org/openxr/openxr/merge_requests/3759)) + - New vendor extension: `XR_META_detached_controllers` + ([internal MR 2467](https://gitlab.khronos.org/openxr/openxr/merge_requests/2467)) + - New vendor extension: `XR_BD_spatial_sensing` + ([internal MR 3429](https://gitlab.khronos.org/openxr/openxr/merge_requests/3429)) + - New vendor extension: `XR_BD_spatial_anchor` + ([internal MR 3435](https://gitlab.khronos.org/openxr/openxr/merge_requests/3435)) + - New vendor extension: `XR_BD_spatial_anchor_sharing` + ([internal MR 3436](https://gitlab.khronos.org/openxr/openxr/merge_requests/3436)) + - New vendor extension: `XR_BD_spatial_scene` + ([internal MR 3438](https://gitlab.khronos.org/openxr/openxr/merge_requests/3438)) + - New vendor extension: `XR_BD_spatial_mesh` + ([internal MR 3439](https://gitlab.khronos.org/openxr/openxr/merge_requests/3439)) + - schema: Allow aliases of function pointers, primarily for use in extension + promotion. + ([internal MR 2989](https://gitlab.khronos.org/openxr/openxr/merge_requests/2989)) +- SDK + - Validation Layer: Fix: Fixes validation layer check for next chain validation + by changing it from recursive to iterative. This allows for subsequent struct + to validate off the initial set of valid chained structs. + ([internal MR 3684](https://gitlab.khronos.org/openxr/openxr/merge_requests/3684), + [internal issue 2434](https://gitlab.khronos.org/openxr/openxr/issues/2434)) + - Validation Layer: Fix: Fixes validation layer check for structs that inherit + off a base struct. Inherited structs also have the same list of valid chained + structs as their parent. + ([internal MR 3684](https://gitlab.khronos.org/openxr/openxr/merge_requests/3684), + [internal issue 2434](https://gitlab.khronos.org/openxr/openxr/issues/2434)) + - Validation Layer: Fix: Fixes null dereference bugs in generated code in layer. + ([internal MR 3684](https://gitlab.khronos.org/openxr/openxr/merge_requests/3684), + [internal issue 2434](https://gitlab.khronos.org/openxr/openxr/issues/2434)) + - Validation Layer: Fix: Adds a validation layer exception to + `xrGetRecommendedLayerResolutionMETA` which allows a `XR_NULL_HANDLE` to be + valid when checking the `XrSwapchainSubImage` struct. + ([internal MR 3689](https://gitlab.khronos.org/openxr/openxr/merge_requests/3689), + [internal issue 2425](https://gitlab.khronos.org/openxr/openxr/issues/2425)) + - Validation Layer: Improvement: Add time stamp to the log messages + ([internal MR 3723](https://gitlab.khronos.org/openxr/openxr/merge_requests/3723)) + - Validation Layer: Improvement: Generate debug messages when `core_validation` + layer starts / exits + ([internal MR 3723](https://gitlab.khronos.org/openxr/openxr/merge_requests/3723)) + - hello_xr: Improvement: Update Android target SDK version to 34 to eliminate + Play Protect warning on install. (Minimum SDK remains 24.) + ([internal MR 3719](https://gitlab.khronos.org/openxr/openxr/merge_requests/3719)) + - list_json: Improvement: Use `XrInstanceCreateInfoAndroidKHR` on Android for + improved compatibility. + ([internal MR 3775](https://gitlab.khronos.org/openxr/openxr/merge_requests/3775)) + +## OpenXR SDK 1.1.46 (2025-03-04) + +This release includes a new ratified Khronos extension, new vendor extensions, +and the ratification of several existing multi-vendor extensions. In the SDK +specifically, Android AAR packages for the loader are now easier to use with a +copy of the loader library in a path supported by older-style build systems, as +well as inclusion of a top-level architecture-independent CMake config/version +file when unpacked for easier use with pure-CMake build systems. + +- Registry + - Chore: Reserve extension numbers. + ([internal MR 3701](https://gitlab.khronos.org/openxr/openxr/merge_requests/3701), + [internal MR 3711](https://gitlab.khronos.org/openxr/openxr/merge_requests/3711), + [internal MR 3722](https://gitlab.khronos.org/openxr/openxr/merge_requests/3722)) + - Chore: Register Sony author ID. + ([internal MR 3709](https://gitlab.khronos.org/openxr/openxr/merge_requests/3709)) + - Fix: XML contained incorrect paths for dpad emulation bindings for + `.../bytedance/pico_neo3_controller`, `.../bytedance/pico4_controller`, + `.../bytedance/pico_g3_controller`, `.../yvr/touch_controller_yvr`, and + `.../microsoft/xbox_controller`. + ([internal MR 3674](https://gitlab.khronos.org/openxr/openxr/merge_requests/3674)) + - Improvement: Ratify a list of shared vendor extensions as well as add support + for the 'ratified' attribute in XML and html generation. See + <https://registry.khronos.org/OpenXR/specs/1.1/extprocess.html> for more + information. + ([internal MR 3494](https://gitlab.khronos.org/openxr/openxr/merge_requests/3494), + [internal issue 2404](https://gitlab.khronos.org/openxr/openxr/issues/2404), + [internal MR 3677](https://gitlab.khronos.org/openxr/openxr/merge_requests/3677)) + - New ratified Khronos extension: `XR_KHR_extended_struct_name_lengths` + ([internal MR 3254](https://gitlab.khronos.org/openxr/openxr/merge_requests/3254), + [internal issue 1664](https://gitlab.khronos.org/openxr/openxr/issues/1664)) + - New vendor extension: `XR_LOGITECH_mx_ink_stylus_interaction` + ([internal MR 3242](https://gitlab.khronos.org/openxr/openxr/merge_requests/3242), + [internal MR 3583](https://gitlab.khronos.org/openxr/openxr/merge_requests/3583), + [internal MR 3584](https://gitlab.khronos.org/openxr/openxr/merge_requests/3584), + [internal MR 3585](https://gitlab.khronos.org/openxr/openxr/merge_requests/3585)) + - New vendor extension: `XR_META_hand_tracking_microgestures` + ([internal MR 3433](https://gitlab.khronos.org/openxr/openxr/merge_requests/3433), + [internal MR 3725](https://gitlab.khronos.org/openxr/openxr/merge_requests/3725)) +- SDK + - Fix: Require both "xcb" and "xcb-glx" modules correctly in order to configure + build for use of xcb headers. + ([internal MR 3703](https://gitlab.khronos.org/openxr/openxr/merge_requests/3703), + [internal issue 2467](https://gitlab.khronos.org/openxr/openxr/issues/2467)) + - Improvement: Refactored usage of Android logging to be more consistent. + ([internal MR 2909](https://gitlab.khronos.org/openxr/openxr/merge_requests/2909)) + - Improvement: In the Android loader AAR, place a copy of the loader library in + the `/jni/ARCH/` directory for older build systems. + ([internal MR 3261](https://gitlab.khronos.org/openxr/openxr/merge_requests/3261), + [internal issue 2285](https://gitlab.khronos.org/openxr/openxr/issues/2285)) + - Improvement: Include cross-architecture CMake config/version files in the root + of the Android `.aar` artifact, allowing it to be unpacked and used easily by + software not using the Android Gradle Plugin and Prefab. + ([internal MR 3658](https://gitlab.khronos.org/openxr/openxr/merge_requests/3658)) + - Update: Upgrade bundled jsoncpp to 1.9.6. + ([internal MR 3502](https://gitlab.khronos.org/openxr/openxr/merge_requests/3502)) + +## OpenXR SDK 1.1.45 (2025-02-05) + +This release includes a new multi-vendor extension, a new vendor extension, +improvements to Android builds and artifacts, and a revision to a new +architecture added in 1.1.42. + +Note that SDK release 1.1.44 was skipped to keep up with a monthly cadence for +patch releases. + +- Registry + - Extension reservation: Reserve 15 extensions for EpicGames. + ([internal MR 3649](https://gitlab.khronos.org/openxr/openxr/merge_requests/3649)) + - Improvement: Clean up spacing in some functions, improving specification and + header output appearance. + ([internal MR 3660](https://gitlab.khronos.org/openxr/openxr/merge_requests/3660)) + - New multi-vendor extension: `XR_EXT_frame_synthesis` + ([internal MR 2200](https://gitlab.khronos.org/openxr/openxr/merge_requests/2200), + [OpenXR-Docs PR 122](https://github.com/KhronosGroup/OpenXR-Docs/pull/122)) + - New vendor extension: `XR_BD_body_tracking` + ([internal MR 2867](https://gitlab.khronos.org/openxr/openxr/merge_requests/2867)) +- SDK + - Change: Update the ABI identifier of LoongArch64 in + `specification/loader/runtime.adoc` and the loader. This introduces a small + incompatibility on this platform, but only if you were already decorating your + manifests with ABI/architecture, which is unlikely. + ([OpenXR-SDK-Source PR 523](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/523)) + - Improvement: Update Gradle (for hello_xr and other tests) from 7.5/7.5.1 to to + 8.5, and Android Gradle Plugin to 8.1.4. + ([internal MR 3640](https://gitlab.khronos.org/openxr/openxr/merge_requests/3640)) + - Improvement: Adjust build so that it is possible to build a new binary `.aar` + file from an unzipped sources.jar file, by calling something like `bash + org/khronos/openxr/openxr_loader_for_android/maintainer-scripts/build-aar.sh`. + ([internal MR 3642](https://gitlab.khronos.org/openxr/openxr/merge_requests/3642)) + - Improvement: In `build-aar.sh`, skip making a sources.jar automatically if we + lack the requirements (such as when we are already building from one.) + ([internal MR 3642](https://gitlab.khronos.org/openxr/openxr/merge_requests/3642)) + +## OpenXR SDK 1.1.43 (2024-11-27) + +This release has a few fixes and minor improvements, as well as support for +several new vendor extensions. It also improves the "loader_test" which was +broken on Android. CMake config files are now also included in the Android +loader AAR distributed for this release, for those not using Gradle and the +Android Gradle Plugin's support of "Prefab" format native libraries to consume +the loader. + +- Registry + - Bump version of `XR_KHR_vulkan_swapchain_format_list` and note that it depends + on either `XR_KHR_vulkan_enable` or `XR_KHR_vulkan_enable2`. + ([internal MR 3418](https://gitlab.khronos.org/openxr/openxr/merge_requests/3418)) + - Fix: Correctly mark `XR_FB_touch_controller_pro` and + `XR_META_touch_controller_plus` as promoted to 1.1. + ([internal MR 3586](https://gitlab.khronos.org/openxr/openxr/merge_requests/3586)) + - Improvement: Small XML formatting/organization cleanups. + ([internal MR 3610](https://gitlab.khronos.org/openxr/openxr/merge_requests/3610)) + - New vendor extension: `XR_ML_facial_expression` + ([internal MR 3100](https://gitlab.khronos.org/openxr/openxr/merge_requests/3100)) + - New vendor extension: `XR_META_passthrough_layer_resumed_event` + ([internal MR 3106](https://gitlab.khronos.org/openxr/openxr/merge_requests/3106)) + - New vendor extensions: `XR_META_colocation_discovery`, + `XR_META_spatial_entity_sharing`, and `XR_META_spatial_entity_group_sharing` + ([internal MR 2782](https://gitlab.khronos.org/openxr/openxr/merge_requests/2782)) + - Reservation: Reserve numbers for spatial extensions. + ([internal MR 3577](https://gitlab.khronos.org/openxr/openxr/merge_requests/3577)) +- SDK + - Fix: loader_test: API version in Android assets, fixes test breakage since + 1.1.x. + ([internal MR 3598](https://gitlab.khronos.org/openxr/openxr/merge_requests/3598)) + - Improvement: Loader test: Update Catch2 from v3.3.2 to v3.7.1. Provides build- + time and runtime performance improvements, among other changes. + ([internal MR 2893](https://gitlab.khronos.org/openxr/openxr/merge_requests/2893)) + - Improvement: Accept command line options to `build-aar.sh`, including one that + allows including CMake configs in case you are building for Android but not + using Gradle and Android Gradle Plugin to consume the `.aar`. + ([internal MR 3423](https://gitlab.khronos.org/openxr/openxr/merge_requests/3423)) + - Improvement: Loader: Update jnipp, used for Android builds. New version + includes a build fix for some environments, as well as a crash fix. + ([internal MR 3589](https://gitlab.khronos.org/openxr/openxr/merge_requests/3589)) + - Improvement: Add `disable_environment` field to the output of + `generate_api_layer_manifest.py` script. + ([internal MR 3591](https://gitlab.khronos.org/openxr/openxr/merge_requests/3591)) + - Improvement: hello_xr: Add Vulkan debug messages during Vulkan instance + creation. + ([internal MR 3592](https://gitlab.khronos.org/openxr/openxr/merge_requests/3592)) + - Improvement: Loader test: Use Catch2 idiomatic assertions and captures to make + it easier to debug. + ([internal MR 3599](https://gitlab.khronos.org/openxr/openxr/merge_requests/3599)) + +## OpenXR SDK 1.1.42 (2024-10-25) + +This release updates a vendor extension with renamed enumerants, adds +architecture support for `loong64`, and delivers substantial improvements and +fixes to the XML registry, particularly the description of interaction profile + +- Registry + - Fix: Update schema to reflect that `XrPathString_t` should allow dash in + interaction profile paths. + ([internal MR 3493](https://gitlab.khronos.org/openxr/openxr/merge_requests/3493)) + - Fix: `XR_VARJO_xr4_controller_interaction` did not properly define its + interaction profile in XML. + ([internal MR 3493](https://gitlab.khronos.org/openxr/openxr/merge_requests/3493), + [internal MR 3548](https://gitlab.khronos.org/openxr/openxr/merge_requests/3548)) + - Fix: Correct XML description of OpenXR 1.1 related additions to the promoted + Meta Touch Plus, Touch Pro, and Touch (Rift CV1) controller interaction + profiles. + ([internal MR 3513](https://gitlab.khronos.org/openxr/openxr/merge_requests/3513), + [internal issue 2350](https://gitlab.khronos.org/openxr/openxr/issues/2350), + [internal issue 2375](https://gitlab.khronos.org/openxr/openxr/issues/2375)) + - Fix: Add missing XML description of `EXT_hand_interaction` additions to several + interaction profiles, and add comments to clarify where profile additions + should be located. + ([internal MR 3517](https://gitlab.khronos.org/openxr/openxr/merge_requests/3517), + [internal MR 3541](https://gitlab.khronos.org/openxr/openxr/merge_requests/3541), + [internal MR 3552](https://gitlab.khronos.org/openxr/openxr/merge_requests/3552)) + - Fix: Corrections to the Schema chapter of the style guide. + ([internal MR 3521](https://gitlab.khronos.org/openxr/openxr/merge_requests/3521)) + - Improvement: Small consistency clean-up. + ([internal MR 3512](https://gitlab.khronos.org/openxr/openxr/merge_requests/3512)) + - Improvement: Clean up `.rnc` schema to improve readability. + ([internal MR 3521](https://gitlab.khronos.org/openxr/openxr/merge_requests/3521)) + - Scripts: Improve `update_version.py` used in release process. + ([internal MR 3543](https://gitlab.khronos.org/openxr/openxr/merge_requests/3543)) + - Update: Change naming convention in `XR_HTC_facial_expression`: rename + `XR_LIP_EXPRESSION_MOUTH_SMILE_RIGHT_HTC` to + `XR_LIP_EXPRESSION_MOUTH_RAISER_RIGHT_HTC`, + `XR_LIP_EXPRESSION_MOUTH_SMILE_LEFT_HTC` to + `XR_LIP_EXPRESSION_MOUTH_RAISER_LEFT_HTC`, + `XR_LIP_EXPRESSION_MOUTH_SAD_RIGHT_HTC` to + `XR_LIP_EXPRESSION_MOUTH_STRETCHER_RIGHT_HTC` and + `XR_LIP_EXPRESSION_MOUTH_SAD_LEFT_HTC` to + `XR_LIP_EXPRESSION_MOUTH_STRETCHER_LEFT_HTC`, providing the old names as + compatibility aliases. + ([internal MR 3408](https://gitlab.khronos.org/openxr/openxr/merge_requests/3408)) +- SDK + - Loader: Fix build error on `loong64`, and add `loong64` in the architecture + table in the loader documentation. + ([OpenXR-SDK-Source PR 479](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/479)) + +## OpenXR SDK 1.1.41 (2024-09-25) + +This release features several new vendor extensions, as well as some small +improvements and fixes to the software. + +- Registry + - Change: Allow structs that can extend multiple other structs in the RelaxNG + schema, as already permitted by the Vulkan schema. + ([internal MR 2869](https://gitlab.khronos.org/openxr/openxr/merge_requests/2869)) + - New vendor extension: `XR_HTC_body_tracking` + ([internal MR 2549](https://gitlab.khronos.org/openxr/openxr/merge_requests/2549)) + - New vendor extension: `XR_ML_spatial_anchors` + ([internal MR 2803](https://gitlab.khronos.org/openxr/openxr/merge_requests/2803)) + - New vendor extension: `XR_ML_spatial_anchors_storage` + ([internal MR 2804](https://gitlab.khronos.org/openxr/openxr/merge_requests/2804)) + - New vendor extension: `XR_ML_system_notifications` + ([internal MR 2946](https://gitlab.khronos.org/openxr/openxr/merge_requests/2946)) + - New vendor extension: `XR_ML_world_mesh_detection` + ([internal MR 2950](https://gitlab.khronos.org/openxr/openxr/merge_requests/2950)) + - New vendor extension: `XR_ML_view_configuration_depth_range_change` + ([internal MR 3036](https://gitlab.khronos.org/openxr/openxr/merge_requests/3036)) +- SDK + - Fix: Do not enforce overly-strict requirements on structs using `*BaseHeader` + types in the code generation scripts, fixing a build-time warning for the + layers. + ([internal MR 3434](https://gitlab.khronos.org/openxr/openxr/merge_requests/3434)) + - Improvement: Migrate CMake build system away from using + `find_package(PythonInterpreter)`, deprecated since CMake 3.12. Use + `find_package(Python3 COMPONENTS Interpreter)` instead. + ([OpenXR-SDK-Source PR 486](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/486), + [internal MR 3472](https://gitlab.khronos.org/openxr/openxr/merge_requests/3472)) + - Validation layer: Improvement: Clean up `generate_vuid_database` script, used + to analyze the validation layer. + ([internal MR 2895](https://gitlab.khronos.org/openxr/openxr/merge_requests/2895)) + - ci: Remove now-redundant gradle-wrapper-validation job from GitHub Actions + ([OpenXR-SDK-Source PR 500](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/500)) + - ci: Add GitHub Action for macOS building + ([OpenXR-SDK-Source PR 501](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/501)) + - doc: Add command to build OpenXR targets on macOS + ([OpenXR-SDK-Source PR 501](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/501)) + - hello_xr: Addition: Log Vulkan extensions requested by runtime and by app, + visible when running with `--verbose`. + ([OpenXR-SDK-Source PR 403](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/403)) + +## OpenXR SDK 1.1.40 (2024-08-22) + +This release features a new ratified graphics API binding extension, +`XR_KHR_metal_enable`, including support in hello_xr. The loader test has had +substantial improvements as well. There are also an assortment of smaller fixes +and improvements. + +- Registry + - Add: New ratified Khronos extension: `XR_KHR_metal_enable`. + ([internal MR 2721](https://gitlab.khronos.org/openxr/openxr/merge_requests/2721)) + - Chore: Reserve 15 extension id numbers for ByteDance. + ([internal MR 3409](https://gitlab.khronos.org/openxr/openxr/merge_requests/3409)) + - Fix: Clarified that views in `XR_VARJO_quad_views` needs to have identical + poses for each eye. + ([internal MR 3396](https://gitlab.khronos.org/openxr/openxr/merge_requests/3396)) + - Fix: Add missing interaction profile extensions for OpenXR 1.1 promoted Meta + interaction profiles. + ([internal MR 3398](https://gitlab.khronos.org/openxr/openxr/merge_requests/3398)) + - Fix: Correctly mark the Magic Leap home button as a system button in the XML. + ([internal MR 3405](https://gitlab.khronos.org/openxr/openxr/merge_requests/3405)) + - Fix: Add `XR_ERROR_VALIDATION_FAILURE` to all functions from + `XR_EXT_conformance_automation`. + ([internal MR 3417](https://gitlab.khronos.org/openxr/openxr/merge_requests/3417)) +- SDK + - API dump layer: Improvement: Move a non-generated function out of the Python- + generated source file. + ([internal MR 3336](https://gitlab.khronos.org/openxr/openxr/merge_requests/3336)) + - API dump layer: Improvement: Clean up usage of RAII mutex lock guards. + ([internal MR 3336](https://gitlab.khronos.org/openxr/openxr/merge_requests/3336)) + - Layers and loader: Improvement: Disambiguate `XrGeneratedDispatchTable` between + loader and API layers. + ([internal MR 3406](https://gitlab.khronos.org/openxr/openxr/merge_requests/3406)) + - Loader test: Improvement: Migrate to use Catch2 (matching the CTS) instead of + an ad-hoc test framework. + ([internal MR 3337](https://gitlab.khronos.org/openxr/openxr/merge_requests/3337)) + - hello_xr: Add: Metal graphics plugin (use `-g Metal`) for running it on macOS + with `XR_KHR_metal_enable` extension. + ([internal MR 3009](https://gitlab.khronos.org/openxr/openxr/merge_requests/3009), + [internal MR 3456](https://gitlab.khronos.org/openxr/openxr/merge_requests/3456)) + - hello_xr: Improvement: Use `XrMatrix4x4f_CreateFromRigidTransform` in place of + `XrMatrix4x4f_CreateTranslationRotationScale` for known rigid transforms. + ([internal MR 3349](https://gitlab.khronos.org/openxr/openxr/merge_requests/3349)) + +**Note**: There is no 1.1.39 release: it was skipped to keep the monthly patch +version increment cadence given the lack of a release in July. + +## OpenXR SDK 1.1.38 (2024-06-09) + +This is a fairly small release, with one new extension and a handful of fixes. + +- Registry + - Addition: New multi-vendor extension: `XR_EXT_composition_layer_inverted_alpha` + ([internal MR 3085](https://gitlab.khronos.org/openxr/openxr/merge_requests/3085), + [internal MR 3385](https://gitlab.khronos.org/openxr/openxr/merge_requests/3385)) + - Chore: Reserve an extension for Logitech. + ([internal MR 3384](https://gitlab.khronos.org/openxr/openxr/merge_requests/3384)) + - Chore: Register author tag for Deep Mirror. + ([OpenXR-Docs PR 171](https://github.com/KhronosGroup/OpenXR-Docs/pull/171)) + - Fix: `XrCompositionLayerPassthroughFB` has a "parentstruct" of + `XrCompositionLayerBaseHeader` (it is based on this type), rather than + "structextends" (in the next chain). Bump extension revision. + ([internal MR 3305](https://gitlab.khronos.org/openxr/openxr/merge_requests/3305)) + - Fix: `XR_EXT_plane_detection`: Fix extents description and plane axis to match + CTS and implementations. + ([internal MR 3374](https://gitlab.khronos.org/openxr/openxr/merge_requests/3374), + [internal issue 2281](https://gitlab.khronos.org/openxr/openxr/issues/2281)) + - Fix: Correct typo in `XR_FB_keyboard_tracking` flag description. + ([internal MR 3393](https://gitlab.khronos.org/openxr/openxr/merge_requests/3393)) +- SDK + - No significant changes + +## OpenXR SDK 1.1.37 (2024-05-23) + +This release primarily adds new defines for easier use of both OpenXR 1.0 and +1.1 with up-to-date headers, some documentation improvements, and improvements +for Android, including support for using the "API Dump" and "Validation" API +layers in your own APK during the development process. + +- Registry + - Addition: New `XR_API_VERSION_1_0` and `XR_API_VERSION_1_1` defines to allow + applications to easily specify OpenXR "major" and "minor" version while passing + through the "patch" version. + ([internal MR 3329](https://gitlab.khronos.org/openxr/openxr/merge_requests/3329), + [internal MR 3354](https://gitlab.khronos.org/openxr/openxr/merge_requests/3354), + [internal issue 2254](https://gitlab.khronos.org/openxr/openxr/issues/2254)) + - Addition: Register Razer vendor ID. + ([internal MR 3340](https://gitlab.khronos.org/openxr/openxr/merge_requests/3340)) + - Fix: Add "palm_pose" to "touch_controller_pro" and "touch_controller_plus" in + XML. + ([internal MR 3363](https://gitlab.khronos.org/openxr/openxr/merge_requests/3363)) + - Improvement: Add Schematron rule to avoid triggering edge cases of vendor tags + ending with X. + ([internal MR 3341](https://gitlab.khronos.org/openxr/openxr/merge_requests/3341)) + - Reservation: Reserve extension numbers for a few new EXT extensions. + ([internal MR 3285](https://gitlab.khronos.org/openxr/openxr/merge_requests/3285), + [internal MR 3292](https://gitlab.khronos.org/openxr/openxr/merge_requests/3292)) + - Update: Bump version of `XR_FB_composition_layer_alpha_blend` due to spec text + clarification. + ([internal MR 3317](https://gitlab.khronos.org/openxr/openxr/merge_requests/3317)) +- SDK + - Addition: Ship `open-in-docker.sh` script for use building the loader design + doc. + ([internal MR 3352](https://gitlab.khronos.org/openxr/openxr/merge_requests/3352), + [internal issue 2283](https://gitlab.khronos.org/openxr/openxr/issues/2283), + [OpenXR-SDK-Source issue 476](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/476)) + - Fix: Fix references to Docker container in spec build instructions and clarify + that most parts do not apply to the SDK-Source repo. + ([internal MR 3352](https://gitlab.khronos.org/openxr/openxr/merge_requests/3352), + [internal issue 2283](https://gitlab.khronos.org/openxr/openxr/issues/2283), + [OpenXR-SDK-Source issue 476](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/476)) + - Fix: Do not load all Android app-supplied layers as explicit, but rather as + their actual type. + ([OpenXR-SDK-Source PR 475](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/475), + [internal issue 2284](https://gitlab.khronos.org/openxr/openxr/issues/2284)) + - Improvement: Use new `XR_API_VERSION_1_0` and `XR_API_VERSION_1_1` defines. + ([internal MR 3329](https://gitlab.khronos.org/openxr/openxr/merge_requests/3329), + [internal issue 2254](https://gitlab.khronos.org/openxr/openxr/issues/2254)) + - Improvement: Add Android support to "api_dump" and "core_validation" API + layers. + ([internal MR 3330](https://gitlab.khronos.org/openxr/openxr/merge_requests/3330)) + +## OpenXR SDK 1.1.36 (2024-04-15) + +This is a substantial update to the OpenXR specification. The OpenXR loader in +this release supports both OpenXR 1.0 and 1.1, and sample applications such as +hello_xr continue to only require OpenXR 1.0. The schema associated with the +`xr.xml` description of OpenXR has received a small but breaking change, so +software that parses it may need an update accordingly. Additionally, the +protocol for the OpenXR loader on Android to communicate with system or +installable runtime brokers has been extended for improvfed backward- and +forward-compatibility; see the changes to the loader design document for more +information. + +- Registry + - New ratified Khronos extension: `XR_KHR_locate_spaces` + ([internal MR 2272](https://gitlab.khronos.org/openxr/openxr/merge_requests/2272), + [internal issue 1706](https://gitlab.khronos.org/openxr/openxr/issues/1706)) + - New ratified Khronos extension: `XR_KHR_maintenance1` + ([internal MR 3053](https://gitlab.khronos.org/openxr/openxr/merge_requests/3053)) + - New ratified OpenXR version: `XR_VERSION_1_1` - OpenXR 1.1. + ([internal MR 3053](https://gitlab.khronos.org/openxr/openxr/merge_requests/3053)) + - New multi-vendor extension: `XR_EXT_future` + ([internal MR 2610](https://gitlab.khronos.org/openxr/openxr/merge_requests/2610)) + - New vendor extension: `XR_META_environment_depth` + ([internal MR 2771](https://gitlab.khronos.org/openxr/openxr/merge_requests/2771), + [internal MR 3271](https://gitlab.khronos.org/openxr/openxr/merge_requests/3271)) + - Mark `XR_OCULUS_android_session_state_enable` as deprecated. + ([internal MR 3255](https://gitlab.khronos.org/openxr/openxr/merge_requests/3255)) + - Update the XML schema to change how dependencies are described (replacing + `requiresCore` and `requires` attributes of `extension`, and `feature` and + `extension` attributes of `require`, with a new `depends` attribute.). This is + a **breaking change** of the XML schema, though in an infrequently processed + attribute. This corresponds to the change made in Vulkan 1.3.241. + ([internal MR 3260](https://gitlab.khronos.org/openxr/openxr/merge_requests/3260)) +- SDK + - API dump layer: Handle opaque futures defined by `XR_EXT_future`. + ([internal MR 2610](https://gitlab.khronos.org/openxr/openxr/merge_requests/2610)) + - API dump layer: Zero initialize out-param in calls to `xrResultToString` and + `xrStructureTypeToString`. + ([internal MR 3284](https://gitlab.khronos.org/openxr/openxr/merge_requests/3284)) + - Android loader: Build using NDK 23.2. + ([internal MR 2992](https://gitlab.khronos.org/openxr/openxr/merge_requests/2992)) + - Android loader: Allow the loader to check multiple records from the broker, for + backward- and forward-compatibility + ([internal MR 3269](https://gitlab.khronos.org/openxr/openxr/merge_requests/3269), + [internal issue 2226](https://gitlab.khronos.org/openxr/openxr/issues/2226)) + - Loader: Improve error logging in the case that the Windows registry + `ActiveRuntime` path cannot be parsed or found. + ([internal MR 3015](https://gitlab.khronos.org/openxr/openxr/merge_requests/3015), + [internal issue 2125](https://gitlab.khronos.org/openxr/openxr/issues/2125)) + - Loader: Remove path separator parsing from Windows registry `ActiveRuntime` + path to fix bug. + ([internal MR 3015](https://gitlab.khronos.org/openxr/openxr/merge_requests/3015)) + - Loader: Fix build issue for ARMv6 architectures, and note architecture naming + quirk of Raspberry Pi OS in the architecture table in the loader documentation. + ([OpenXR-SDK-Source PR 464](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/464), + [OpenXR-SDK-Source issue 463](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/463)) + - Reduce duplication of environment variable getters and setters. + ([internal MR 3039](https://gitlab.khronos.org/openxr/openxr/merge_requests/3039)) + - Updates to scripts and software to handle aliases and promoted functionality in + `XR_KHR_maintenance1` and `XR_VERSION_1_1` + ([internal MR 3053](https://gitlab.khronos.org/openxr/openxr/merge_requests/3053)) + - hello_xr: Fix Windows mirror window acquire, wait, present loop. + ([internal MR 3289](https://gitlab.khronos.org/openxr/openxr/merge_requests/3289)) + - hello_xr and other samples: Update Android compile SDK version (to 33), NDK + version (to 23.2), and build tools version (to 34.0.0). + ([internal MR 2992](https://gitlab.khronos.org/openxr/openxr/merge_requests/2992)) + - hello_xr and runtime list: Request an OpenXR 1.0 instance by default. + ([internal MR 3320](https://gitlab.khronos.org/openxr/openxr/merge_requests/3320)) + - loader_test: Build fixes to allow loader_test to compile / run on Android. + ([internal MR 3153](https://gitlab.khronos.org/openxr/openxr/merge_requests/3153)) + +## OpenXR SDK 1.0.34 (2024-02-16) + +This release features a number of new multi-vendor and vendor extensions, +additional functionality in the reflection header, as well as compatibility +improvements for the loader on Android. + +- Registry + - Extension reservation: Register author ID and reserve extensions for Leia. + ([internal MR 3203](https://gitlab.khronos.org/openxr/openxr/merge_requests/3203)) + - Fix: Remove erroneous interaction profile component additions from extensions. + ([internal MR 3223](https://gitlab.khronos.org/openxr/openxr/merge_requests/3223)) + - New multi-vendor extension: `XR_EXT_user_presence` + ([internal MR 2706](https://gitlab.khronos.org/openxr/openxr/merge_requests/2706), + [internal issue 1585](https://gitlab.khronos.org/openxr/openxr/issues/1585)) + - New vendor extension: `XR_META_recommended_layer_resolution` + ([internal MR 2570](https://gitlab.khronos.org/openxr/openxr/merge_requests/2570)) + - New vendor extension: `XR_META_automatic_layer_filter` + ([internal MR 2696](https://gitlab.khronos.org/openxr/openxr/merge_requests/2696)) + - New vendor extension: `XR_META_spatial_entity_mesh` + ([internal MR 2773](https://gitlab.khronos.org/openxr/openxr/merge_requests/2773)) + - New vendor extension: `XR_FB_face_tracking2` + ([internal MR 2811](https://gitlab.khronos.org/openxr/openxr/merge_requests/2811)) + - New vendor extension: `XR_VARJO_xr4_controller_interaction` + ([internal MR 3078](https://gitlab.khronos.org/openxr/openxr/merge_requests/3078)) + - `XR_FB_scene`: Update to spec version 4. + ([internal MR 2774](https://gitlab.khronos.org/openxr/openxr/merge_requests/2774)) + - `XR_META_headset_id` and `XR_FB_spatial_entity`: Drop `XR_EXT_uuid` dependency, + they use the data structure but do not require any runtime support specific to + `XR_EXT_uuid` + ([internal MR 2577](https://gitlab.khronos.org/openxr/openxr/merge_requests/2577)) +- SDK + - API Layers: Add version-script for linking API Layers on Linux and Android. + ([internal MR 3112](https://gitlab.khronos.org/openxr/openxr/merge_requests/3112)) + - Fix typo in `gfxwrapper_opengl` that did not affect the use in this repository + directly, but may affect downstream users of this code. + ([internal MR 3215](https://gitlab.khronos.org/openxr/openxr/merge_requests/3215)) + - Loader: fix to Android Loader so that the + `/<path_to_apk>/my_apk_file.apk!/libs/libstuff.so` will not get blocked + ([internal MR 3054](https://gitlab.khronos.org/openxr/openxr/merge_requests/3054)) + - Loader: Add missing ifdef guards for `XR_KHR_LOADER_INIT_SUPPORT`. + ([internal MR 3152](https://gitlab.khronos.org/openxr/openxr/merge_requests/3152), + [internal MR 3159](https://gitlab.khronos.org/openxr/openxr/merge_requests/3159)) + - Loader: Fix crash in case of calling `xrEnumerateInstanceExtensionProperties` + before calling `xrInitializeLoaderKHR` on Android. + ([internal MR 3159](https://gitlab.khronos.org/openxr/openxr/merge_requests/3159)) + - Loader design: Add a note about environment variables being ignored when run on + Windows as admin. + ([internal MR 3214](https://gitlab.khronos.org/openxr/openxr/merge_requests/3214)) + - `openxr_reflection.h`: Add macros to list functions provided by each feature / + extension. + ([internal MR 3129](https://gitlab.khronos.org/openxr/openxr/merge_requests/3129)) + - external: Update Jinja2 Python module shipped with repository (for source code + generation) to 2.11.3. + ([internal MR 3221](https://gitlab.khronos.org/openxr/openxr/merge_requests/3221), + [internal MR 3237](https://gitlab.khronos.org/openxr/openxr/merge_requests/3237)) + +## OpenXR SDK 1.0.33 (2024-01-03) + +This release primarily adds new ratified functionality describing the loader +interaction with runtimes and API layers. Corresponding definitions are now in +the official `openxr_loader_negotiation.h` generated header, rather than the +`loader_interfaces.h` header previously shipped only with the OpenXR-SDK-Source +repository. This change only affects vendors of runtimes and API layers as well +as contributors to the OpenXR loader: applications do not directly use this API, +the loader uses it on their behalf. A number of other small fixes are also +included. + +- Registry + - Extension reservation: Update author ID and reserve extensions for Varjo. + ([internal MR 3083](https://gitlab.khronos.org/openxr/openxr/merge_requests/3083)) + - Extension reservation: Reserve 10 extension ids each for `ANDROIDX` & + `ANDROIDSYS`. + ([internal MR 3086](https://gitlab.khronos.org/openxr/openxr/merge_requests/3086)) + - Khronos ratified addition: Specify the existing loader negotiation functions + (without modification) in the XML, moving from `loader_interfaces.h` to a new + generated header `openxr_loader_negotiation.h`. + ([internal MR 2807](https://gitlab.khronos.org/openxr/openxr/merge_requests/2807), + [internal issue 1953](https://gitlab.khronos.org/openxr/openxr/issues/1953)) + - `XR_KHR_android_thread_settings`: Fix the description of + `XrAndroidThreadTypeKHR` enum values - they were swapped relative to their + implicit meaning from their name. + ([internal MR 3077](https://gitlab.khronos.org/openxr/openxr/merge_requests/3077)) + - `XR_MNDX_egl_enable`: Update version to 2 to reflect function pointer type + change released in 1.0.29. + ([OpenXR-Docs PR 159](https://github.com/KhronosGroup/OpenXR-Docs/pull/159)) +- SDK + - Loader: Fix loader build on Universal Windows Platform: build-system-only + change. (Included in SDK hotfix 1.0.32.1.) + ([internal MR 3071](https://gitlab.khronos.org/openxr/openxr/merge_requests/3071)) + - Loader: Correctly destroy the LoaderInstance when loader is done. + ([internal MR 3041](https://gitlab.khronos.org/openxr/openxr/merge_requests/3041)) + - Remove obsolete `loader_interfaces.h` header, migrating uses (in loader and + layers) to use the newly specified and ratified `openxr_loader_negotiation.h`, + and adjust scripts for the addition of the loader negotiation APIs. + ([internal MR 2807](https://gitlab.khronos.org/openxr/openxr/merge_requests/2807), + [internal issue 1953](https://gitlab.khronos.org/openxr/openxr/issues/1953), + [internal MR 3122](https://gitlab.khronos.org/openxr/openxr/merge_requests/3122)) +- Misc + - Update/correct names. + - Ship a `.mailmap` file in the public repositories, maintained separately + from the larger one used in the private monorepo, to correct names/emails + and unify contributor identities. + - Update Khronos Group copyright dates. + +## OpenXR SDK 1.0.32 (2023-11-29) + +This release contains a number of vendor extensions, plus a new ratified +revision to the `XR_KHR_loader_init` extension that specifies forwarding the +init calls to API layers. **Vendors of API layers**, primarily on Android, must +verify they can handle being passed `XR_NULL_HANDLE` for the instance parameter +of `xrGetInstanceProcAddr`, to avoid bugs when using the updated loader. This +release also contains a number of build system cleanups and fixes. Users of the +Android Gradle Plugin and our official loader AAR file can now use the +`OpenXR::headers` target just like on desktop: there is now metadata for the +"prefab" tool to generate for CMake both this header/include-only target and the +normal `OpenXR::openxr_loader` imported library target. The shipped AAR is much +smaller due to stripping debug data from the binaries, which helps in case +application build systems do not automatically strip native binaries. A bug in +the loader Android manifest as shipped in 1.0.31 has also been fixed. + +- Registry + - Extension reservation: Reserve extension id for `XR_KHR_maintenance1` + ([internal MR 3010](https://gitlab.khronos.org/openxr/openxr/merge_requests/3010)) + - Extension reservation: Reserve extension id for `XR_KHR_game_controller` + ([internal MR 3019](https://gitlab.khronos.org/openxr/openxr/merge_requests/3019)) + - New vendor extension: `XR_HTC_anchor` + ([internal MR 2667](https://gitlab.khronos.org/openxr/openxr/merge_requests/2667)) + - New vendor extension: `XR_META_touch_controller_plus` + ([internal MR 2702](https://gitlab.khronos.org/openxr/openxr/merge_requests/2702)) + - New vendor extension: `XR_ML_marker_understanding` + ([internal MR 2750](https://gitlab.khronos.org/openxr/openxr/merge_requests/2750)) + - New vendor extension: `XR_ML_localization_map` + ([internal MR 2802](https://gitlab.khronos.org/openxr/openxr/merge_requests/2802), + [internal MR 3045](https://gitlab.khronos.org/openxr/openxr/merge_requests/3045), + [internal MR 3047](https://gitlab.khronos.org/openxr/openxr/merge_requests/3047)) + - `XR_KHR_loader_init`: New Khronos ratified revision, adds support for + forwarding loader init calls to API layers + ([internal MR 2703](https://gitlab.khronos.org/openxr/openxr/merge_requests/2703)) +- SDK + - Loader: Pass `xrInitializeLoaderKHR` calls to enabled API layers if + `XR_KHR_loader_init` is enabled, per ratified update to that extension. + ([internal MR 2703](https://gitlab.khronos.org/openxr/openxr/merge_requests/2703)) + - Loader: Partial fix for the loader not honoring + `BUILD_LOADER_WITH_EXCEPTION_HANDLING` on Android. + ([internal MR 2870](https://gitlab.khronos.org/openxr/openxr/merge_requests/2870), + [OpenXR-SDK-Source PR 405](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/405), + [internal issue 1999](https://gitlab.khronos.org/openxr/openxr/issues/1999)) + - Loader Android AAR: Strip binaries before inclusion in AAR, as loader is stable + (and mostly shared with all platforms) and size difference is substantial. + - Loader Android AAR: Expose `OpenXR::headers` prefab imported target just as on + desktop builds + ([internal MR 2886](https://gitlab.khronos.org/openxr/openxr/merge_requests/2886)) + - Loader Android AAR: Generate a source jar file for completeness. + ([internal MR 2886](https://gitlab.khronos.org/openxr/openxr/merge_requests/2886)) + - Loader Android AAR: Add `<uses-sdk>` elements to Android loader AAR manifest, + to prevent the manifest merger from assuming a version < 4 and adding unneeded + permissions accordingly. + ([internal MR 3029](https://gitlab.khronos.org/openxr/openxr/merge_requests/3029)) + ([internal MR 3032](https://gitlab.khronos.org/openxr/openxr/merge_requests/3032)) + - Clean up our CMake build substantially, correcting dependencies and narrowing + the scope of includes. + ([internal MR 2886](https://gitlab.khronos.org/openxr/openxr/merge_requests/2886), + [OpenXR-SDK-Source issue 344](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/344), + [internal issue 1872](https://gitlab.khronos.org/openxr/openxr/issues/1872), + [OpenXR-SDK-Source issue 419](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/419), + [internal issue 2071](https://gitlab.khronos.org/openxr/openxr/issues/2071), + [internal MR 2987](https://gitlab.khronos.org/openxr/openxr/merge_requests/2987)) + - Fix build in directories containing spaces. + ([internal MR 2886](https://gitlab.khronos.org/openxr/openxr/merge_requests/2886), + [OpenXR-SDK-Source issue 344](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/344), + [internal issue 1872](https://gitlab.khronos.org/openxr/openxr/issues/1872), + [OpenXR-SDK-Source issue 419](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/419), + [internal issue 2071](https://gitlab.khronos.org/openxr/openxr/issues/2071), + [internal MR 2987](https://gitlab.khronos.org/openxr/openxr/merge_requests/2987)) + - Fix linking to GLX when glvnd is not found on the system + ([internal MR 3000](https://gitlab.khronos.org/openxr/openxr/merge_requests/3000)) + - Fix use of `OpenXR::headers` target when not building the loader. + ([internal MR 2886](https://gitlab.khronos.org/openxr/openxr/merge_requests/2886), + [OpenXR-SDK-Source issue 344](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/344), + [internal issue 1872](https://gitlab.khronos.org/openxr/openxr/issues/1872), + [OpenXR-SDK-Source issue 419](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/419), + [internal issue 2071](https://gitlab.khronos.org/openxr/openxr/issues/2071), + [internal MR 2987](https://gitlab.khronos.org/openxr/openxr/merge_requests/2987)) + - scripts: Migrate `namedtuple` usage to dataclass, and expose the definitions + for reuse. + ([internal MR 2183](https://gitlab.khronos.org/openxr/openxr/merge_requests/2183)) + - scripts: Clean up formatting, clean up some issues found by type-aware Python + editors, and improve the experience of editing Python scripts in some editors + by adding a `.env` file. + ([internal MR 2183](https://gitlab.khronos.org/openxr/openxr/merge_requests/2183)) + - scripts: Support base header types with no derived types defined yet. + ([internal MR 2802](https://gitlab.khronos.org/openxr/openxr/merge_requests/2802)) + +## OpenXR SDK 1.0.31 (2023-10-18) + +This release features two new vendor extensions and minor extension XML +revisions, in addition to compatibility and logging improvements in the +software. + +- Registry + - Extension reservation: Reserve extensions for NVIDIA. + ([internal MR 2952](https://gitlab.khronos.org/openxr/openxr/merge_requests/2952)) + - Extension reservation: Reserve extensions for Meta. + ([internal MR 2959](https://gitlab.khronos.org/openxr/openxr/merge_requests/2959)) + - Extension reservation: Reserve extensions for Android. + ([internal MR 2966](https://gitlab.khronos.org/openxr/openxr/merge_requests/2966)) + - Extension reservation: Reserve an extension for `XR_KHR_egl_enable`. + ([internal MR 2982](https://gitlab.khronos.org/openxr/openxr/merge_requests/2982)) + - New vendor extension: `XR_MSFT_scene_marker` + ([internal MR 2601](https://gitlab.khronos.org/openxr/openxr/merge_requests/2601)) + - New vendor extension: `XR_ML_user_calibration` + ([internal MR 2849](https://gitlab.khronos.org/openxr/openxr/merge_requests/2849)) + - Schematron: Allow chained structs that extend a two-call-idiom struct to carry + only a `*CapacityInput` member. + ([internal MR 2892](https://gitlab.khronos.org/openxr/openxr/merge_requests/2892), + [internal issue 2059](https://gitlab.khronos.org/openxr/openxr/issues/2059)) + - `XR_FB_render_model`: Fix `structextends` attribute and remove `returnedonly` + attribute of `XrRenderModelCapabilitiesRequestFB`, to match the specification + prose. + ([internal MR 2765](https://gitlab.khronos.org/openxr/openxr/merge_requests/2765), + [OpenXR-Docs issue 153](https://github.com/KhronosGroup/OpenXR-Docs/issues/153), + [internal issue 2017](https://gitlab.khronos.org/openxr/openxr/issues/2017)) + - xml: Fixed a few errors in MSFT extensions discovered by Schematron checks. + ([internal MR 2892](https://gitlab.khronos.org/openxr/openxr/merge_requests/2892)) +- SDK + - API Layers: Add logging on API layer negotiation failure. + ([internal MR 2926](https://gitlab.khronos.org/openxr/openxr/merge_requests/2926)) + - Fix: Enable build with clang-cl on Windows through Visual Studio. + ([internal MR 2948](https://gitlab.khronos.org/openxr/openxr/merge_requests/2948)) + - Fix: Remove unused pthread prototypes declaration in `_USE_GNU` ifdef, fixing + builds on some systems. + ([internal MR 2981](https://gitlab.khronos.org/openxr/openxr/merge_requests/2981)) + - Fix comment typo in platform utils header. + ([internal MR 2991](https://gitlab.khronos.org/openxr/openxr/merge_requests/2991)) + - gfxwrapper: Add OpenGL 3.3 functions to an internal utility library used by + hello_xr, shared with the CTS. + ([internal MR 2941](https://gitlab.khronos.org/openxr/openxr/merge_requests/2941)) + - loader: Modify `jnipp`, used by the loader on Android, to no longer use + `basic_string<>` with types that are technically not in the C++ specification + as permissible, to fix compatibility with an upcoming `libc++` update. + ([internal MR 2974](https://gitlab.khronos.org/openxr/openxr/merge_requests/2974), + [internal issue 2094](https://gitlab.khronos.org/openxr/openxr/issues/2094), + [OpenXR-SDK-Source PR 426](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/426)) + - loader_test: Refactor to use existing macros for all test to avoid repetition. + ([internal MR 2922](https://gitlab.khronos.org/openxr/openxr/merge_requests/2922)) + - scripts: Small fixes and cleanups + ([internal MR 2998](https://gitlab.khronos.org/openxr/openxr/merge_requests/2998), + [internal MR 2894](https://gitlab.khronos.org/openxr/openxr/merge_requests/2894), + [internal MR 2896](https://gitlab.khronos.org/openxr/openxr/merge_requests/2896)) + +## OpenXR SDK 1.0.30 (2023-09-20) + +This release is primarily a quality improvement release, fixing a range of +issues in the registry and SDK, including fixing a loader bug related to layers, +in addition to a new vendor extension and an updated vendor extension. + +- Registry + - Add missing enum tags for enum-sized array struct members. + ([internal MR 2731](https://gitlab.khronos.org/openxr/openxr/merge_requests/2731)) + - Fix EGL "get proc addr" function pointer typedef. + ([internal MR 2939](https://gitlab.khronos.org/openxr/openxr/merge_requests/2939)) + - New vendor extension: `XR_YVR_controller_interaction` + ([internal MR 2841](https://gitlab.khronos.org/openxr/openxr/merge_requests/2841)) + - `XR_BD_controller_interaction`: Add support for G3 devices + ([internal MR 2872](https://gitlab.khronos.org/openxr/openxr/merge_requests/2872)) + - Fix specification errors highlighted by fixed tooling. + ([internal MR 2923](https://gitlab.khronos.org/openxr/openxr/merge_requests/2923)) +- SDK + - Add installable manual page for `openxr_runtime_list_json`. + ([internal MR 2899](https://gitlab.khronos.org/openxr/openxr/merge_requests/2899)) + - Remove unused diagram exports from loader directory. + ([internal MR 2907](https://gitlab.khronos.org/openxr/openxr/merge_requests/2907)) + - Update URLs in manual pages. + ([internal MR 2935](https://gitlab.khronos.org/openxr/openxr/merge_requests/2935)) + - Validation Layer: Remove conditional `XR_KHR_headless` support as the extension + is not part of OpenXR 1.0. + ([internal MR 2901](https://gitlab.khronos.org/openxr/openxr/merge_requests/2901)) + - build system: Add CTest support for running the loader test. + ([internal MR 2289](https://gitlab.khronos.org/openxr/openxr/merge_requests/2289), + [OpenXR-SDK-Source issue 309](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/309), + [internal issue 1733](https://gitlab.khronos.org/openxr/openxr/issues/1733)) + - hello_xr: Clean up how we specify the default graphics plugin on Android. + ([internal MR 2917](https://gitlab.khronos.org/openxr/openxr/merge_requests/2917)) + - list_json: Add missing return statement for exit code. + ([internal MR 2936](https://gitlab.khronos.org/openxr/openxr/merge_requests/2936)) + - loader: fix for implicit/explicit api layer loading logic + ([OpenXR-SDK-Source PR 421](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/421), + [internal issue 2079](https://gitlab.khronos.org/openxr/openxr/issues/2079)) + +## OpenXR SDK 1.0.29 (2023-08-25) + +This release contains several fixes to the specification registry, improvements +to the loader, layers, and loader test, as well as enhancements to the loader +documentation/specification to support architecture and ABI specific active +runtime manifest names on Linux and Android. + +- Registry + - Change `PFNEGLGETPROCADDRESSPROC` (for `eglGetProcAddress`) to a locally + defined type to avoid compiler errors. + ([internal MR 2468](https://gitlab.khronos.org/openxr/openxr/merge_requests/2468)) + - Extension reservation: Register author ID and reserve vendor extensions for + YVR. + ([internal MR 2832](https://gitlab.khronos.org/openxr/openxr/merge_requests/2832)) + - New vendor extension: `XR_META_passthrough_preferences` + ([internal MR 2694](https://gitlab.khronos.org/openxr/openxr/merge_requests/2694)) + - `XR_HTCX_vive_tracker_interaction`: Added new role paths for wrists and ankles. + ([internal MR 2728](https://gitlab.khronos.org/openxr/openxr/merge_requests/2728)) +- SDK + - Changes also included in 1.0.28.1 SDK hotfix release + - layers: Build with `/bigobj` or equivalent on Windows due to increased number + of generated functions with spec growth. + ([internal MR 2837](https://gitlab.khronos.org/openxr/openxr/merge_requests/2837), + [internal issue 2051](https://gitlab.khronos.org/openxr/openxr/issues/2051), + [OpenXR-SDK-Source PR 414](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/414)) + - Changes also included in 1.0.28.2 SDK hotfix release + - Android AAR artifacts (loader) and hello_xr: Fix `<queries>` element contents. + ([internal MR 2840](https://gitlab.khronos.org/openxr/openxr/merge_requests/2840), + [internal issue 2053](https://gitlab.khronos.org/openxr/openxr/issues/2053)) + - Android AAR artifacts: Fix C++ standard library selection for Android artifacts + in `build-aar.sh` + ([internal MR 2836](https://gitlab.khronos.org/openxr/openxr/merge_requests/2836), + [internal issue 2052](https://gitlab.khronos.org/openxr/openxr/issues/2052)) + - Android AAR artifacts: Use `jar` instead of 7-zip to perform archiving, and + document requirements in `build-aar.sh` + ([internal MR 2836](https://gitlab.khronos.org/openxr/openxr/merge_requests/2836), + [OpenXR-SDK-Source issue 303](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/303), + [internal issue 1711](https://gitlab.khronos.org/openxr/openxr/issues/1711)) + - build system: Support SDK hotfix versions (fourth version component). + ([internal MR 2836](https://gitlab.khronos.org/openxr/openxr/merge_requests/2836)) + - Add XrVector2f length function to `xr_linear.h` + ([internal MR 2876](https://gitlab.khronos.org/openxr/openxr/merge_requests/2876)) + - Add build.gradle files for list_json, c_compile_test. + ([internal MR 2908](https://gitlab.khronos.org/openxr/openxr/merge_requests/2908)) + - Change `PFNEGLGETPROCADDRESSPROC` (for `eglGetProcAddress`) to a locally + defined type to avoid compiler errors. + ([internal MR 2468](https://gitlab.khronos.org/openxr/openxr/merge_requests/2468)) + - Enable `loader_test` tests which require a valid extension + ([internal MR 2790](https://gitlab.khronos.org/openxr/openxr/merge_requests/2790)) + - Fix building hello_xr with mingw compiler. + ([internal MR 2850](https://gitlab.khronos.org/openxr/openxr/merge_requests/2850)) + - Improvement: Reduce size of dispatch table in OpenXR loader. (Full size table + still shipped in OpenXR-SDK even though it is not used by the loader anymore.) + ([internal MR 2810](https://gitlab.khronos.org/openxr/openxr/merge_requests/2810), + [internal MR 2842](https://gitlab.khronos.org/openxr/openxr/merge_requests/2842)) + - Maintenance script updates. + ([internal MR 2900](https://gitlab.khronos.org/openxr/openxr/merge_requests/2900)) + - loader: Add support for architecture-specific active runtime manifests for + Linux, macOS, and Android. + ([internal MR 2450](https://gitlab.khronos.org/openxr/openxr/merge_requests/2450), + [internal issue 2066](https://gitlab.khronos.org/openxr/openxr/issues/2066), + [internal MR 2871](https://gitlab.khronos.org/openxr/openxr/merge_requests/2871)) + - loader: refactor to use jnipp on Android + ([internal MR 2812](https://gitlab.khronos.org/openxr/openxr/merge_requests/2812)) + - loader: disable `loader_test` if api layer building is disabled + ([internal MR 2843](https://gitlab.khronos.org/openxr/openxr/merge_requests/2843)) + - loader_test: Replace session test with action test to make test more + maintainable. + ([internal MR 2786](https://gitlab.khronos.org/openxr/openxr/merge_requests/2786)) + - validation layer: Fix deadlock when calling `XR_EXT_debug_utils` functions. + ([internal MR 2865](https://gitlab.khronos.org/openxr/openxr/merge_requests/2865)) + +## OpenXR SDK 1.0.28 (2023-07-10) + +This release contains improved compatibility and code quality fixes for the +loader, support for loading certain API layers on Android-based devices, and a +number of other improvements, in addition to the new extensions. Additionally, +the loader documentation now describes how OpenXR handles compatibility with +Android API levels of 30 and above: runtimes may need to update accordingly to +support this compatibility solution. + +- **OpenXR SDK 1.0.28.2** hotfix release includes the following fixes + - Loader spec: Fix description of `<queries>` element contents: existing + description would fail to install. + ([internal MR 2840](https://gitlab.khronos.org/openxr/openxr/merge_requests/2840), + [internal issue 2053](https://gitlab.khronos.org/openxr/openxr/issues/2053)) + - Android AAR artifacts (loader) and hello_xr: Fix `<queries>` element contents. + ([internal MR 2840](https://gitlab.khronos.org/openxr/openxr/merge_requests/2840), + [internal issue 2053](https://gitlab.khronos.org/openxr/openxr/issues/2053)) + - Android AAR artifacts: Fix C++ standard library selection for Android artifacts + in `build-aar.sh` + ([internal MR 2836](https://gitlab.khronos.org/openxr/openxr/merge_requests/2836), + [internal issue 2052](https://gitlab.khronos.org/openxr/openxr/issues/2052)) + - Android AAR artifacts: Use `jar` instead of 7-zip to perform archiving, and + document requirements in `build-aar.sh` + ([internal MR 2836](https://gitlab.khronos.org/openxr/openxr/merge_requests/2836), + [OpenXR-SDK-Source issue 303](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/303), + [internal issue 1711](https://gitlab.khronos.org/openxr/openxr/issues/1711)) + - build system: Support SDK hotfix versions (fourth version component). + ([internal MR 2836](https://gitlab.khronos.org/openxr/openxr/merge_requests/2836)) +- **OpenXR SDK 1.0.28.1** hotfix release includes the following fix + - API dump layer: Fix build on Windows on ARM64. + ([OpenXR-SDK-Source PR 414](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/414)) +- Registry + - Added defines to `xr.xml` for extension enum base and enum stride. + ([internal MR 2693](https://gitlab.khronos.org/openxr/openxr/merge_requests/2693), + [OpenXR-Docs issue 148](https://github.com/KhronosGroup/OpenXR-Docs/issues/148), + [internal issue 1979](https://gitlab.khronos.org/openxr/openxr/issues/1979)) + - Extension reservation: Reserve an extension for `XR_EXT_future` + ([internal MR 2631](https://gitlab.khronos.org/openxr/openxr/merge_requests/2631)) + - Extension reservation: Register `ANDROID` author ID and reserve 15 extensions + for it. + ([internal MR 2690](https://gitlab.khronos.org/openxr/openxr/merge_requests/2690)) + - Extension reservation: Reserve extensions for "user presence" and "locate + spaces" + ([internal MR 2705](https://gitlab.khronos.org/openxr/openxr/merge_requests/2705)) + - Extension reservation: Reserve 25 extensions for Magic Leap. + ([internal MR 2778](https://gitlab.khronos.org/openxr/openxr/merge_requests/2778)) + - Extension reservation: Reserve extension for `XR_KHR_extendable_action_binding` + ([internal MR 2779](https://gitlab.khronos.org/openxr/openxr/merge_requests/2779)) + - Fix spelling. + ([internal MR 2766](https://gitlab.khronos.org/openxr/openxr/merge_requests/2766)) + - Fixed the error code specification for `xrGetControllerModelPropertiesMSFT` + function. + ([internal MR 2600](https://gitlab.khronos.org/openxr/openxr/merge_requests/2600)) + - New multi-vendor extension: `XR_EXT_hand_interaction` + ([internal MR 2116](https://gitlab.khronos.org/openxr/openxr/merge_requests/2116)) + - New multi-vendor extension: `XR_EXT_plane_detection` + ([internal MR 2510](https://gitlab.khronos.org/openxr/openxr/merge_requests/2510), + [internal MR 2791](https://gitlab.khronos.org/openxr/openxr/merge_requests/2791)) + - New multi-vendor extension: `XR_EXT_hand_tracking_data_source` + ([internal MR 2568](https://gitlab.khronos.org/openxr/openxr/merge_requests/2568)) + - New vendor extension: `XR_META_passthrough_color_lut` + ([internal MR 2507](https://gitlab.khronos.org/openxr/openxr/merge_requests/2507)) + - New vendor extension: `XR_META_virtual_keyboard` + ([internal MR 2555](https://gitlab.khronos.org/openxr/openxr/merge_requests/2555)) + - New vendor extension: `XR_OPPO_controller_interaction` + ([OpenXR-Docs PR 146](https://github.com/KhronosGroup/OpenXR-Docs/pull/146)) + - Update Magic Leap contact + ([internal MR 2699](https://gitlab.khronos.org/openxr/openxr/merge_requests/2699)) + - `XR_FB_face_tracking`: Non-functional registry change, fixing a problem with + standalone headers. + ([internal MR 2663](https://gitlab.khronos.org/openxr/openxr/merge_requests/2663)) + - `XR_FB_scene`: Introduce `XrSemanticLabelsSupportInfoFB` and bump spec version + to 3. + ([internal MR 2682](https://gitlab.khronos.org/openxr/openxr/merge_requests/2682)) + - `XR_FB_spatial_entity` and `XR_FB_scene`: Add `XR_ERROR_SIZE_INSUFFICIENT` + return code to functions which use the two-call idiom. + ([internal MR 2718](https://gitlab.khronos.org/openxr/openxr/merge_requests/2718)) + - `XR_FB_touch_controller_pro`: Fix XML to require the `touch_controller_pro` + interaction profile for the extension + ([internal MR 2806](https://gitlab.khronos.org/openxr/openxr/merge_requests/2806)) + - registry: Remove extraneous whitespace from some commands. + ([OpenXR-SDK-Source PR 397](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/397)) + - schematron: Improve self tests. + ([internal MR 2680](https://gitlab.khronos.org/openxr/openxr/merge_requests/2680)) + - schematron: Require vendor tag on interaction profile paths introduced by + extensions. + ([internal MR 2684](https://gitlab.khronos.org/openxr/openxr/merge_requests/2684)) + - scripts: Allow schematron to check an alternate XML file. + ([internal MR 2670](https://gitlab.khronos.org/openxr/openxr/merge_requests/2670)) +- SDK + - Allow compilation of OpenXR SDK on Mac + ([internal MR 2788](https://gitlab.khronos.org/openxr/openxr/merge_requests/2788), + [internal MR 2789](https://gitlab.khronos.org/openxr/openxr/merge_requests/2789), + [internal MR 2790](https://gitlab.khronos.org/openxr/openxr/merge_requests/2790), + [internal MR 2800](https://gitlab.khronos.org/openxr/openxr/merge_requests/2800)) + - Common: Add `stdint.h` include to `platform_utils.hpp` for GCC 13+ + ([OpenXR-SDK-Source PR 406](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/406)) + - Describe building OpenXR SDK on macOS with Xcode + ([internal MR 2768](https://gitlab.khronos.org/openxr/openxr/merge_requests/2768)) + - Handle clang-format-16 in `runClangFormat.sh`, and adjust source files so its + output matches the earlier version used on CI. + ([internal MR 2666](https://gitlab.khronos.org/openxr/openxr/merge_requests/2666), + [internal MR 2814](https://gitlab.khronos.org/openxr/openxr/merge_requests/2814)) + - Improvement: Fix clang warning `-Wundef`. + ([internal MR 2717](https://gitlab.khronos.org/openxr/openxr/merge_requests/2717)) + - Improvement: Fix leftover warnings when building with `-Wall`. + ([internal MR 2754](https://gitlab.khronos.org/openxr/openxr/merge_requests/2754), + [OpenXR-SDK-Source PR 410](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/410)) + - Loader: On Android, use a single logcat tag for all parts of the loader. + ([internal MR 2688](https://gitlab.khronos.org/openxr/openxr/merge_requests/2688)) + - Loader: Update the required `queries` elements for an OpenXR application on + Android, so that runtime and layer components loaded in the application process + may access their own package in API >29. + ([internal MR 2708](https://gitlab.khronos.org/openxr/openxr/merge_requests/2708)) + - Loader: Search system directories for API layer manifests on Android + ([internal MR 2709](https://gitlab.khronos.org/openxr/openxr/merge_requests/2709)) + - Loader: Add Product and OEM partition to active runtime search path on Android + ([internal MR 2709](https://gitlab.khronos.org/openxr/openxr/merge_requests/2709)) + - Loader: Improve casting to `uint32_t` edge case handling. + ([internal MR 2745](https://gitlab.khronos.org/openxr/openxr/merge_requests/2745)) + - Loader: Clear possible dangling `next` pointers in `XR_EXT_debug_utils` label + structures. + ([internal MR 2764](https://gitlab.khronos.org/openxr/openxr/merge_requests/2764)) + - Validation Layer: Fix the validation_layer_generator to not check static array + addresses. + ([OpenXR-SDK-Source PR 399](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/399)) + - api_layers: Update API Layers spec section in README.md + ([internal MR 2753](https://gitlab.khronos.org/openxr/openxr/merge_requests/2753)) + - cmake: Set up alias targets `OpenXR::openxr_loader` and `OpenXR::headers` so + that the loader and headers may be used the same whether you used + `find_package(OpenXR)` on binaries or have included the source tree as a + subproject. + ([internal MR 2793](https://gitlab.khronos.org/openxr/openxr/merge_requests/2793)) + - gradle: Add license for gradlew and gradlew.bat + ([internal MR 2725](https://gitlab.khronos.org/openxr/openxr/merge_requests/2725)) + - gradle: General cleanup and updates of Android build system. + ([internal MR 2796](https://gitlab.khronos.org/openxr/openxr/merge_requests/2796)) + - hello_xr: Enable building with latest Android Studio canary + ([OpenXR-SDK-Source PR 393](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/393)) + - layers: Code cleanup and calling convention fixes + ([internal MR 2784](https://gitlab.khronos.org/openxr/openxr/merge_requests/2784)) + - loader test: Fix for Windows 32-bit + ([internal MR 2784](https://gitlab.khronos.org/openxr/openxr/merge_requests/2784)) + - loader test: Fix CMake dependencies. + ([internal MR 2776](https://gitlab.khronos.org/openxr/openxr/merge_requests/2776)) + +## OpenXR SDK 1.0.27 (2023-03-21) + +This release contains a large list of improvements, including interaction +profile definitions in machine-readable format in the XML, consistent tool-based +formatting of the XML, a new `list_json` tool to ease updates to +[OpenXR-Inventory][], and a wide variety of new vendor and multi-vendor +extensions, in addition to a collection of smaller improvements. + +[OpenXR-Inventory]: https://github.com/KhronosGroup/OpenXR-Inventory + +- Registry + - Add interaction profile definitions to `xr.xml` + ([internal MR 2485](https://gitlab.khronos.org/openxr/openxr/merge_requests/2485)) + - Chore: Format the full XML API registry with + [PrettyRegistryXML](https://github.com/rpavlik/PrettyRegistryXml), making some + small changes by hand to clean up. + ([internal MR 2540](https://gitlab.khronos.org/openxr/openxr/merge_requests/2540), + [internal MR 2329](https://gitlab.khronos.org/openxr/openxr/merge_requests/2329), + [OpenXR-SDK-Source PR 373](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/373), + [OpenXR-Docs PR 14](https://github.com/KhronosGroup/OpenXR-Docs/pull/14), + [OpenXR-CTS PR 50](https://github.com/KhronosGroup/OpenXR-CTS/pull/50), + [OpenXR-SDK PR 12](https://github.com/KhronosGroup/OpenXR-SDK/pull/12)) + - Document how to generate a standalone header file for an extension. + ([internal MR 2627](https://gitlab.khronos.org/openxr/openxr/merge_requests/2627)) + - Extension reservation: Register author ID and reserve vendor extensions for + Logitech. + ([internal MR 2504](https://gitlab.khronos.org/openxr/openxr/merge_requests/2504)) + - Extension reservation: Reserve an extension number for a multi-vendor + extension. + ([internal MR 2520](https://gitlab.khronos.org/openxr/openxr/merge_requests/2520)) + - Extension reservation: Reserve an extension for `XR_EXT_hand_tracking_usage` + ([internal MR 2550](https://gitlab.khronos.org/openxr/openxr/merge_requests/2550)) + - Extension reservation: Reserve extension id 430 for `XR_EXT_plane_detection` + ([internal MR 2565](https://gitlab.khronos.org/openxr/openxr/merge_requests/2565)) + - Extension reservation: Reserve vendor extensions for Monado. + ([internal MR 2613](https://gitlab.khronos.org/openxr/openxr/merge_requests/2613)) + - Extension reservation: Reserve vendor extensions for ACER. + ([OpenXR-Docs PR 142](https://github.com/KhronosGroup/OpenXR-Docs/pull/142)) + - Extension reservation: Reserve a vendor extension for OPPO. + ([OpenXR-Docs PR 145](https://github.com/KhronosGroup/OpenXR-Docs/pull/145)) + - New vendor extension: `XR_FB_composition_layer_depth_test` + ([internal MR 2208](https://gitlab.khronos.org/openxr/openxr/merge_requests/2208), + [internal issue 1657](https://gitlab.khronos.org/openxr/openxr/issues/1657)) + - New vendor extension: `XR_META_foveation_eye_tracked` + ([internal MR 2239](https://gitlab.khronos.org/openxr/openxr/merge_requests/2239), + [internal MR 2273](https://gitlab.khronos.org/openxr/openxr/merge_requests/2273), + [internal MR 2332](https://gitlab.khronos.org/openxr/openxr/merge_requests/2332)) + - New vendor extension: `XR_QCOM_tracking_optimization_settings` + ([internal MR 2261](https://gitlab.khronos.org/openxr/openxr/merge_requests/2261), + [internal issue 1703](https://gitlab.khronos.org/openxr/openxr/issues/1703)) + - New vendor extension: `XR_META_local_dimming` + ([internal MR 2267](https://gitlab.khronos.org/openxr/openxr/merge_requests/2267), + [internal MR 2595](https://gitlab.khronos.org/openxr/openxr/merge_requests/2595)) + - New vendor extension: `XR_FB_spatial_entity_sharing` + ([internal MR 2274](https://gitlab.khronos.org/openxr/openxr/merge_requests/2274)) + - New vendor extension: `XR_FB_scene_capture` + ([internal MR 2286](https://gitlab.khronos.org/openxr/openxr/merge_requests/2286)) + - New vendor extension: `XR_FB_spatial_entity_storage_batch` + ([internal MR 2312](https://gitlab.khronos.org/openxr/openxr/merge_requests/2312)) + - New vendor extension: `XR_FB_haptic_amplitude_envelope` + ([internal MR 2326](https://gitlab.khronos.org/openxr/openxr/merge_requests/2326)) + - New vendor extension: `XR_FB_touch_controller_pro` + ([internal MR 2327](https://gitlab.khronos.org/openxr/openxr/merge_requests/2327), + [internal issue 1916](https://gitlab.khronos.org/openxr/openxr/issues/1916)) + - New vendor extension: `XR_FB_haptic_pcm` + ([internal MR 2329](https://gitlab.khronos.org/openxr/openxr/merge_requests/2329)) + - New vendor extension: `FB_face_tracking` + ([internal MR 2334](https://gitlab.khronos.org/openxr/openxr/merge_requests/2334), + [internal MR 2539](https://gitlab.khronos.org/openxr/openxr/merge_requests/2539)) + - New vendor extension: `XR_FB_eye_tracking_social` + ([internal MR 2336](https://gitlab.khronos.org/openxr/openxr/merge_requests/2336), + [internal MR 2576](https://gitlab.khronos.org/openxr/openxr/merge_requests/2576)) + - New vendor extension: `XR_FB_body_tracking` + ([internal MR 2339](https://gitlab.khronos.org/openxr/openxr/merge_requests/2339), + [internal MR 2575](https://gitlab.khronos.org/openxr/openxr/merge_requests/2575)) + - New vendor extension: `XR_OCULUS_external_camera` + ([internal MR 2397](https://gitlab.khronos.org/openxr/openxr/merge_requests/2397), + [internal MR 2344](https://gitlab.khronos.org/openxr/openxr/merge_requests/2344)) + - New vendor extension: `XR_FB_spatial_entity_user` + ([internal MR 2407](https://gitlab.khronos.org/openxr/openxr/merge_requests/2407)) + - New vendor extension: `XR_FB_touch_controller_proximity` + ([internal MR 2412](https://gitlab.khronos.org/openxr/openxr/merge_requests/2412)) + - New vendor extension: `XR_ML_global_dimmer` + ([internal MR 2461](https://gitlab.khronos.org/openxr/openxr/merge_requests/2461)) + - New vendor extension: `XR_ML_frame_end_info` + ([internal MR 2462](https://gitlab.khronos.org/openxr/openxr/merge_requests/2462), + [internal MR 2536](https://gitlab.khronos.org/openxr/openxr/merge_requests/2536)) + - New vendor extension: `XR_ML_compat` + ([internal MR 2473](https://gitlab.khronos.org/openxr/openxr/merge_requests/2473)) + - New vendor extension: `XR_EXT_local_floor` + ([internal MR 2503](https://gitlab.khronos.org/openxr/openxr/merge_requests/2503), + [internal issue 746](https://gitlab.khronos.org/openxr/openxr/issues/746), + [internal issue 1606](https://gitlab.khronos.org/openxr/openxr/issues/1606), + [OpenXR-Docs issue 103](https://github.com/KhronosGroup/OpenXR-Docs/issues/103)) + - New vendor extension: `XR_BD_controller_interaction` + ([internal MR 2527](https://gitlab.khronos.org/openxr/openxr/merge_requests/2527)) + - New vendor extension: `XR_MNDX_force_feedback_curl` + ([OpenXR-Docs PR 136](https://github.com/KhronosGroup/OpenXR-Docs/pull/136)) + - Register author ID for Matthieu Bucchianeri. + ([OpenXR-Docs PR 143](https://github.com/KhronosGroup/OpenXR-Docs/pull/143)) + - Rename tag name to a short one for ByteDance. + ([internal MR 2502](https://gitlab.khronos.org/openxr/openxr/merge_requests/2502)) + - Schema: Add initial tests for Schematron rules. + ([internal MR 2512](https://gitlab.khronos.org/openxr/openxr/merge_requests/2512)) + - Schema: Add author ID schematron checks and change duplicate name/number report + to an assert + ([internal MR 2514](https://gitlab.khronos.org/openxr/openxr/merge_requests/2514)) + - Schema: Fix Relax-NG checks of naming convention, and add naming convention + checks to Schematron. + ([internal MR 2538](https://gitlab.khronos.org/openxr/openxr/merge_requests/2538)) + - Schematron: Update extension naming rule to allow for vendor tags to be + followed by an X for experimental and a version number + ([internal MR 2518](https://gitlab.khronos.org/openxr/openxr/merge_requests/2518)) + - scripts: Let `deprecated` override `provisional` when choosing extension table + of contents section. + ([internal MR 2547](https://gitlab.khronos.org/openxr/openxr/merge_requests/2547)) + - scripts: Fix leftover exclusion of `extensions/meta` from `checkMarkup` now + that it no longer generated files. + ([internal MR 2560](https://gitlab.khronos.org/openxr/openxr/merge_requests/2560)) +- SDK + - Experimental Extension Naming: Allow vendor tags to be followed by an "X" for + experimental and an optional version number (e.g. XR_EXTX2_hand_tracking). + Update source generator vendor checks accordingly + ([internal MR 2518](https://gitlab.khronos.org/openxr/openxr/merge_requests/2518)) + - Fix typo in API Dump generation script + ([internal MR 2608](https://gitlab.khronos.org/openxr/openxr/merge_requests/2608)) + - Loader: Fix dynamic build on MinGW. + ([OpenXR-SDK-Source PR 362](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/362), + [OpenXR-SDK-Source issue 367](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/367)) + - Loader and layers: In debug builds, log when non-empty environment variables + are being ignored due to executing with elevated privilege. + ([OpenXR-SDK-Source PR 336](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/336)) + - Loader doc: Minor cleanups to API layer section. + ([internal MR 2581](https://gitlab.khronos.org/openxr/openxr/merge_requests/2581)) + - Loader doc: Fix incorrect markup/dead links. + ([internal MR 2598](https://gitlab.khronos.org/openxr/openxr/merge_requests/2598)) + - Remove third-party dependencies in `external/include/utils`. + ([internal MR 2528](https://gitlab.khronos.org/openxr/openxr/merge_requests/2528)) + - Update all XrStructureType initialization to use standard OpenXR style. + ([internal MR 2557](https://gitlab.khronos.org/openxr/openxr/merge_requests/2557)) + - Update URLs with branch names in manpages. + ([internal MR 2648](https://gitlab.khronos.org/openxr/openxr/merge_requests/2648)) + - Validation layer: Fix function signature for xrNegotiateLoaderApiLayerInterface + in core validation api layer + ([internal MR 2607](https://gitlab.khronos.org/openxr/openxr/merge_requests/2607), + [OpenXR-SDK-Source issue 378](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/378), + [internal issue 1929](https://gitlab.khronos.org/openxr/openxr/issues/1929)) + - clang-format: Add clang-format-15 as acceptable clang formats + ([OpenXR-SDK-Source PR 359](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/359)) + - doc: Add VS 2022 version code to BUILDING.md + ([OpenXR-SDK-Source PR 381](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/381)) + - headers: Remove spurious space in preprocessor conditional, that was causing + `defined` to be treated as an operator. + ([internal MR 2491](https://gitlab.khronos.org/openxr/openxr/merge_requests/2491)) + - hello_xr: Correct domain in Android package identifier. + ([internal MR 2513](https://gitlab.khronos.org/openxr/openxr/merge_requests/2513)) + - hello_xr: Update Vulkan plugin to use the newer `VK_EXT_debug_utils` extension, + and provide names for most Vulkan objects used by the app to aid in debugging. + (Utility code shared with CTS.) + ([internal MR 2524](https://gitlab.khronos.org/openxr/openxr/merge_requests/2524), + [internal MR 2579](https://gitlab.khronos.org/openxr/openxr/merge_requests/2579), + [internal MR 2637](https://gitlab.khronos.org/openxr/openxr/merge_requests/2637)) + - hello_xr: Zero initialize XrSwapchainImage* structs + ([internal MR 2551](https://gitlab.khronos.org/openxr/openxr/merge_requests/2551)) + - hello_xr: Export built-in NativeActivity + ([OpenXR-SDK-Source PR 358](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/358)) + - hello_xr: Use correct lost event count + ([OpenXR-SDK-Source PR 359](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/359)) + - loader: Prefer cstdio and cstdlib for c++ files + ([OpenXR-SDK-Source PR 357](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/357)) + - loader,api_layers: Fix finding wayland-client.h on linux + ([OpenXR-SDK-Source PR 346](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/346)) + - sdk-source: Add `list_json`, a small app to print json similar to the schema + used by [OpenXR-Inventory](https://github.com/KhronosGroup/OpenXR-Inventory). + ([internal MR 2541](https://gitlab.khronos.org/openxr/openxr/merge_requests/2541), + [internal MR 2658](https://gitlab.khronos.org/openxr/openxr/merge_requests/2658)) + - xr_linear.h: Add some extra linear algebra functions + ([internal MR 2532](https://gitlab.khronos.org/openxr/openxr/merge_requests/2532)) + +## OpenXR SDK 1.0.26 (2022-11-18) + +This release contains new reflection headers, fixes and improvements to the +loader and hello_xr (especially on Android), some spec clarifications, +improvements to tooling, and a variety of new vendor and multi-vendor +extensions. + +- Registry + - Add new `XR_EXT_active_action_set_priority` vendor extension. + ([internal MR 2288](https://gitlab.khronos.org/openxr/openxr/merge_requests/2288), + [internal issue 1699](https://gitlab.khronos.org/openxr/openxr/issues/1699)) + - Add new `XR_HTC_passthrough` vendor extension. + ([internal MR 2349](https://gitlab.khronos.org/openxr/openxr/merge_requests/2349)) + - Add new `XR_HTC_foveation` vendor extension. + ([internal MR 2377](https://gitlab.khronos.org/openxr/openxr/merge_requests/2377)) + - Add a warning to `XR_COMPOSITION_LAYER_CORRECT_CHROMATIC_ABERRATION_BIT` saying + that it is not in use and planned for deprecation + ([internal MR 2378](https://gitlab.khronos.org/openxr/openxr/merge_requests/2378), + [internal issue 1751](https://gitlab.khronos.org/openxr/openxr/issues/1751)) + - Add new `XR_META_headset_id` vendor extension. + ([internal MR 2410](https://gitlab.khronos.org/openxr/openxr/merge_requests/2410)) + - Improve Schematron rules for the registry XML and update the tool version used. + ([internal MR 2418](https://gitlab.khronos.org/openxr/openxr/merge_requests/2418), + [internal MR 2426](https://gitlab.khronos.org/openxr/openxr/merge_requests/2426), + [internal MR 2457](https://gitlab.khronos.org/openxr/openxr/merge_requests/2457), + [internal MR 2460](https://gitlab.khronos.org/openxr/openxr/merge_requests/2460), + [internal MR 2465](https://gitlab.khronos.org/openxr/openxr/merge_requests/2465)) + - Register author ID and reserve vendor extensions for ByteDance. + ([internal MR 2482](https://gitlab.khronos.org/openxr/openxr/merge_requests/2482), + [OpenXR-Docs PR 137](https://github.com/KhronosGroup/OpenXR-Docs/pull/137)) + - Register author ID for danwillm and reserve vendor extensions. + ([OpenXR-Docs PR 138](https://github.com/KhronosGroup/OpenXR-Docs/pull/138)) + - Reserve vendor extensions for Microsoft. + ([internal MR 2478](https://gitlab.khronos.org/openxr/openxr/merge_requests/2478)) + - `XR_EXTX_overlay`: Fix XML markup to correct generated valid usage for the + event structure. + ([internal MR 2307](https://gitlab.khronos.org/openxr/openxr/merge_requests/2307)) + - `XR_EXT_performance_settings`: Fix XML markup to correct generated valid usage, + bump revision. + ([internal MR 2306](https://gitlab.khronos.org/openxr/openxr/merge_requests/2306)) + - `XR_HTCX_vive_tracker_interaction`: Fix XML markup to correct generated valid + usage for the event structure. + ([internal MR 2310](https://gitlab.khronos.org/openxr/openxr/merge_requests/2310)) + - `XR_HTC_facial_tracking`: Update vendor extension to version 2. + ([internal MR 2416](https://gitlab.khronos.org/openxr/openxr/merge_requests/2416)) + - specification/scripts: Added new functionality in codegen scripts to support + creating single extension headers. Usage: `python3 scripts/genxr.py -registry + registry/xr.xml -standaloneExtension XR_FB_color_space standalone_header` + ([internal MR 2417](https://gitlab.khronos.org/openxr/openxr/merge_requests/2417)) +- SDK + - In-line comments added to `openxr_reflection.h` + ([internal MR 2357](https://gitlab.khronos.org/openxr/openxr/merge_requests/2357)) + - New `openxr_reflection_structs.h` and `openxr_reflection_parent_structs.h` + reflection headers, containing additional, limited reflection expansion macro + definitions. + ([internal MR 2357](https://gitlab.khronos.org/openxr/openxr/merge_requests/2357)) + - loader: Add missing `RegCloseKey` call. + ([internal MR 2433](https://gitlab.khronos.org/openxr/openxr/merge_requests/2433)) + - loader: Report STL usage as "none" in script-built Android AAR because we + expose no C++ symbols. + ([OpenXR-SDK-Source PR 332](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/332), + [internal issue 1829](https://gitlab.khronos.org/openxr/openxr/issues/1829), + [internal issue 1831](https://gitlab.khronos.org/openxr/openxr/issues/1831)) + - loader: Minor changes to fix a missing-prototypes warning/error. + ([OpenXR-SDK-Source PR 345](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/345)) + - hello_xr: Correctly handle the case of 0 items returned in the Vulkan plugin. + ([internal MR 2363](https://gitlab.khronos.org/openxr/openxr/merge_requests/2363)) + - hello_xr: Android exit should use `ANativeActivity_finish`. + ([internal MR 2409](https://gitlab.khronos.org/openxr/openxr/merge_requests/2409), + [OpenXR-SDK-Source issue 329](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/329), + [internal issue 1820](https://gitlab.khronos.org/openxr/openxr/issues/1820)) + - hello_xr: Simplify platform plugin for POSIX platforms. + ([internal MR 2443](https://gitlab.khronos.org/openxr/openxr/merge_requests/2443), + [internal MR 2436](https://gitlab.khronos.org/openxr/openxr/merge_requests/2436)) + - hello_xr: Minor tidy up of initialization code. + ([internal MR 2449](https://gitlab.khronos.org/openxr/openxr/merge_requests/2449)) + - hello_xr: Add `android.permission.VIBRATE` permission needed by some runtimes + for the controller haptics. + ([internal MR 2486](https://gitlab.khronos.org/openxr/openxr/merge_requests/2486)) + - hello_xr: Bump Android Gradle Plugin usage to 7.0.4 to fix building of hello_xr + on M1 device + ([OpenXR-SDK-Source PR 334](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/334)) + - cmake: Use standard `CMAKE_INSTALL_INCLUDEDIR` to specify included directories. + ([OpenXR-SDK-Source PR 347](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/347)) + - Android: Remove Gradle build files from loader directory: they were unused + because the Android Gradle Plugin could not build our AAR file correctly as + desired. + ([internal MR 2453](https://gitlab.khronos.org/openxr/openxr/merge_requests/2453)) + - Android: Upgrade to gradle version 7. + ([internal MR 2474](https://gitlab.khronos.org/openxr/openxr/merge_requests/2474)) + - Enable dependabot for GitHub Actions. + ([OpenXR-SDK-Source PR 351](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/351), + [OpenXR-SDK-Source PR 352](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/352), + [OpenXR-SDK-Source PR 256](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/256)) + - Fix CI generation of NuGet packages. + ([OpenXR-SDK-Source PR 350](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/350)) + - Improve GitHub CI for OpenXR-SDK-Source. + ([OpenXR-SDK-Source PR 351](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/351), + [OpenXR-SDK-Source PR 352](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/352), + [OpenXR-SDK-Source PR 256](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/256)) + +## OpenXR SDK 1.0.25 (2022-09-02) + +This release contains a few specification clarifications and consistency +improvements, as well as some new vendor extensions. The OpenXR loader for +Android now supports API layers packaged in the application APK, which is +important for running the conformance tests, and which may also be used for +running with the validation layer enabled during application development, for +example. The loader design doc has been updated accordingly. The spec generation +toolchain scripts have been synchronized with Vulkan. Hello_XR now models the +recommended approach for selecting an environment blend mode, among other fixes. + +- Registry + - Add new `XR_ML_ml2_controller_interaction` vendor extension. + ([internal MR 2344](https://gitlab.khronos.org/openxr/openxr/merge_requests/2344)) + - Clarification: Note that all specialized swapchain image structures are + "returnedonly", which removes some unneeded generated implicit valid usage. + ([internal MR 2303](https://gitlab.khronos.org/openxr/openxr/merge_requests/2303)) + - Clarification: Note that all event structs are "returnedonly", which removes + some unneeded generated implicit valid usage. + ([internal MR 2305](https://gitlab.khronos.org/openxr/openxr/merge_requests/2305)) + - Register author ID for Oppo. + ([OpenXR-Docs PR 129](https://github.com/KhronosGroup/OpenXR-Docs/pull/129)) + - Register author ID for Fred Emmott. + ([OpenXR-Docs PR 131](https://github.com/KhronosGroup/OpenXR-Docs/pull/131)) + - Register author ID for Acer. + ([OpenXR-Docs PR 132](https://github.com/KhronosGroup/OpenXR-Docs/pull/132)) + - Reserve extension numbers for anticipated cross-vendor and Khronos extensions. + ([internal MR 2337](https://gitlab.khronos.org/openxr/openxr/merge_requests/2337), + [internal MR 2338](https://gitlab.khronos.org/openxr/openxr/merge_requests/2338), + [internal MR 2389](https://gitlab.khronos.org/openxr/openxr/merge_requests/2389)) + - Reserve a vendor extension for Huawei. + ([internal MR 2356](https://gitlab.khronos.org/openxr/openxr/merge_requests/2356)) + - Reserve vendor extensions for MNDX. + ([OpenXR-Docs PR 133](https://github.com/KhronosGroup/OpenXR-Docs/pull/133)) + - Update `XR_MSFT_scene_understanding` and + `XR_MSFT_scene_understanding_serialization` vendor extensions to list error + codes that may be returned by functions. + ([internal MR 2316](https://gitlab.khronos.org/openxr/openxr/merge_requests/2316)) + - `XR_FB_color_space`: Mark `XrSystemColorSpacePropertiesFB` as "returned-only" + for consistency and to correct the implicit valid usage. + ([internal MR 2304](https://gitlab.khronos.org/openxr/openxr/merge_requests/2304)) + - `XR_FB_display_refresh_rate`: Mark `XrEventDataDisplayRefreshRateChangedFB` as + "returned only" for consistency. + ([internal MR 2308](https://gitlab.khronos.org/openxr/openxr/merge_requests/2308)) + - `XR_FB_hand_tracking_mesh`: Fix two-call-idiom markup for + `XrHandTrackingMeshFB`, affecting implicit valid usage, and increment the + revision. + ([internal MR 2311](https://gitlab.khronos.org/openxr/openxr/merge_requests/2311)) + - `XR_FB_passthrough`: Add `XrSystemPassthroughProperties2FB` and + `XR_PASSTHROUGH_LAYER_DEPTH_BIT_FB`, update spec version to 3. + ([internal MR 2333](https://gitlab.khronos.org/openxr/openxr/merge_requests/2333)) + - `XR_FB_render_model`: Mark `XrRenderModelCapabilitiesRequestFB` as "returned- + only" for consistency and to correct the implicit valid usage. + ([internal MR 2309](https://gitlab.khronos.org/openxr/openxr/merge_requests/2309)) +- SDK + - Loader design doc: Correct a wrong description of extension implementation + chosen by the loader when duplicates. + ([internal MR 2324](https://gitlab.khronos.org/openxr/openxr/merge_requests/2324), + [internal issue 1731](https://gitlab.khronos.org/openxr/openxr/issues/1731)) + - hello_xr: Model the recommended behavior of choosing first blend mode + enumerated by xrEnumerateEnvironmentBlendModes that is supported by the app. + ([internal MR 2352](https://gitlab.khronos.org/openxr/openxr/merge_requests/2352)) + - hello_xr: Fix exit on Android. + ([internal MR 2403](https://gitlab.khronos.org/openxr/openxr/merge_requests/2403)) + - loader: Add Android support for API Layers bundled in the application APK. + ([internal MR 2350](https://gitlab.khronos.org/openxr/openxr/merge_requests/2350)) + - loader: Move validation checks before initialization to avoid potential nullptr + dereference + ([internal MR 2365](https://gitlab.khronos.org/openxr/openxr/merge_requests/2365)) + - loader: On Android, make sure we always build with the same C++ standard + library (static) whether using shell script or gradle. + ([internal MR 2366](https://gitlab.khronos.org/openxr/openxr/merge_requests/2366)) + - loader: add -DXR_OS_APPLE define on macOS (fixes compilation on macOS) + ([OpenXR-SDK-Source PR 323](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/323)) + - scripts: Synchronize scripts with Vulkan, and move all generated files into a + single target directory. + ([internal MR 2335](https://gitlab.khronos.org/openxr/openxr/merge_requests/2335), + [internal issue 1693](https://gitlab.khronos.org/openxr/openxr/issues/1693), + [internal MR 2393](https://gitlab.khronos.org/openxr/openxr/merge_requests/2393), + [internal MR 2400](https://gitlab.khronos.org/openxr/openxr/merge_requests/2400)) + - scripts: Remove spurious warning from codegen script. + ([internal MR 2341](https://gitlab.khronos.org/openxr/openxr/merge_requests/2341)) + - validation layer: Fix output to `XR_EXT_debug_utils` when no labels/names have + been defined. + ([internal MR 2375](https://gitlab.khronos.org/openxr/openxr/merge_requests/2375)) + +## OpenXR SDK 1.0.24 (2022-06-23) + +- Registry + - Add new `XR_EXT_palm_pose` multi-vendor extension. + ([internal MR 2112](https://gitlab.khronos.org/openxr/openxr/merge_requests/2112)) + - Add new `XR_FB_scene` vendor extension. + ([internal MR 2237](https://gitlab.khronos.org/openxr/openxr/merge_requests/2237)) + - Fix structure definition in `XR_FB_spatial_entity_container`. + ([internal MR 2278](https://gitlab.khronos.org/openxr/openxr/merge_requests/2278)) + - scripts: Teach xr_conventions that 2D, 3D, etc. are words for the purposes of + structure type enum generation. + ([internal MR 2237](https://gitlab.khronos.org/openxr/openxr/merge_requests/2237)) +- SDK + - Loader: Fix filename and native lib dir sequence for log + ([OpenXR-SDK-Source PR 311](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/311)) + - Loader: Fix loader building with Gradle and add CI checking for loader building + with Gradle + ([OpenXR-SDK-Source PR 312](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/312)) + - hello_xr: Pick background clear color based on the selected environment blend + mode. + ([internal MR 2275](https://gitlab.khronos.org/openxr/openxr/merge_requests/2275)) + - hello_xr: Defer Vulkan CPU sync until the next frame begins. + ([OpenXR-SDK-Source PR 277](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/277)) + - hello_xr: Fix shader compile on Mali driver + ([OpenXR-SDK-Source PR 310](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/310)) + - scripts: Delegate generating structure types to the conventions object as done + elsewhere in the repo. + ([internal MR 2237](https://gitlab.khronos.org/openxr/openxr/merge_requests/2237)) + +## OpenXR SDK 1.0.23 (2022-05-27) + +This release primarily features a large number of new vendor and multi-vendor +extensions, as well as some updates to existing extensions. Some improvements +and fixes were made in SDK as well. + +- Registry + - Add new `XR_ULTRALEAP_hand_tracking_forearm` vendor extension. + ([internal MR 2154](https://gitlab.khronos.org/openxr/openxr/merge_requests/2154)) + - Add new `XR_EXT_dpad_binding` multi-vendor extension. + ([internal MR 2159](https://gitlab.khronos.org/openxr/openxr/merge_requests/2159)) + - Add "externally synchronized" markup for `xrBeginFrame` and `xrEndFrame` so + they get the matching box and their session parameters are included in the list + of externally-synchronized parameters in the "Threading" section. + ([internal MR 2179](https://gitlab.khronos.org/openxr/openxr/merge_requests/2179), + [OpenXR-Docs issue 23](https://github.com/KhronosGroup/OpenXR-Docs/issues/23), + [internal issue 1216](https://gitlab.khronos.org/openxr/openxr/issues/1216)) + - Add new `XR_FB_spatial_entity` vendor extension. + ([internal MR 2194](https://gitlab.khronos.org/openxr/openxr/merge_requests/2194)) + - Add new `XR_FB_spatial_entity_storage` vendor extension. + ([internal MR 2194](https://gitlab.khronos.org/openxr/openxr/merge_requests/2194)) + - Add new `XR_FB_spatial_entity_query` vendor extension. + ([internal MR 2194](https://gitlab.khronos.org/openxr/openxr/merge_requests/2194)) + - Add new `XR_FB_composition_layer_settings` vendor extension. + ([internal MR 2221](https://gitlab.khronos.org/openxr/openxr/merge_requests/2221)) + - Add new `XR_FB_spatial_entity_container` vendor extension. + ([internal MR 2236](https://gitlab.khronos.org/openxr/openxr/merge_requests/2236)) + - Add new `XR_HTC_vive_wrist_tracker_interaction` vendor extension. + ([internal MR 2252](https://gitlab.khronos.org/openxr/openxr/merge_requests/2252)) + - Add XR_HTC_hand_interaction extension. + ([internal MR 2254](https://gitlab.khronos.org/openxr/openxr/merge_requests/2254)) + - Add new `XR_VARJO_view_offset` vendor extension. + ([internal MR 2255](https://gitlab.khronos.org/openxr/openxr/merge_requests/2255)) + - Add new `XR_META_performance_metrics` vendor extension. + ([internal MR 2256](https://gitlab.khronos.org/openxr/openxr/merge_requests/2256)) + - Add new `XR_META_vulkan_swapchain_create_info` vendor extension. + ([internal MR 2257](https://gitlab.khronos.org/openxr/openxr/merge_requests/2257)) + - Change the XML type of `XR_MIN_COMPOSITION_LAYERS_SUPPORTED` so it outputs an + includable snippet for the spec text. + ([internal MR 2201](https://gitlab.khronos.org/openxr/openxr/merge_requests/2201), + [internal issue 1652](https://gitlab.khronos.org/openxr/openxr/issues/1652), + [OpenXR-Docs issue 117](https://github.com/KhronosGroup/OpenXR-Docs/issues/117)) + - Fix registry consistency script and codegen scripts to allow extension of KHR + and EXT enumerations with vendor-specific members. + ([internal MR 2213](https://gitlab.khronos.org/openxr/openxr/merge_requests/2213), + [internal MR 2243](https://gitlab.khronos.org/openxr/openxr/merge_requests/2243)) + - Fix warning print statement arguments in header generation/validation script. + ([internal MR 2244](https://gitlab.khronos.org/openxr/openxr/merge_requests/2244)) + - Reserve the extension number for multi-vendor hand interaction profile + extension. + ([internal MR 2206](https://gitlab.khronos.org/openxr/openxr/merge_requests/2206)) + - Reserve vendor extensions 304-317 for Qualcomm + ([internal MR 2258](https://gitlab.khronos.org/openxr/openxr/merge_requests/2258)) + - Reserve vendor extensions 318-370 for HTC. + ([internal MR 2266](https://gitlab.khronos.org/openxr/openxr/merge_requests/2266)) + - `KHR_composition_layer_depth`: Update spec version to 6 for updated spec text. + ([internal MR 2207](https://gitlab.khronos.org/openxr/openxr/merge_requests/2207), + [internal issue 1651](https://gitlab.khronos.org/openxr/openxr/issues/1651)) + - `XR_EXT_eye_gaze_interaction`: Update the spec version for spec text change. + ([internal MR 2227](https://gitlab.khronos.org/openxr/openxr/merge_requests/2227)) + - `XR_EXT_uuid`: Add enum tags to `XR_UUID_SIZE_EXT` to ensure it is defined + before `XrUuidEXT` in generated header + ([internal MR 2234](https://gitlab.khronos.org/openxr/openxr/merge_requests/2234), + [internal issue 1673](https://gitlab.khronos.org/openxr/openxr/issues/1673)) + - `XR_FB_hand_aim_tracking`, `XR_FB_hand_tracking_capsule`, + `XR_FB_hand_tracking_mesh`: Fix documentation to specify correct `next` chain + usage. + ([internal MR 2229](https://gitlab.khronos.org/openxr/openxr/merge_requests/2229)) + - `XR_FB_hand_tracking_capsules`: Update `XrHandCapsuleFB` and + `XrHandTrackingCapsulesStateFB` to use + `XR_HAND_TRACKING_CAPSULE_POINT_COUNT_FB` and + `XR_HAND_TRACKING_CAPSULE_COUNT_FB` enums when defining arrays so they match + the usual practice for vendor extensions + ([internal MR 2216](https://gitlab.khronos.org/openxr/openxr/merge_requests/2216)) + - `XR_FB_passthrough_keyboard_hands`: Add + `XR_PASSTHROUGH_LAYER_PURPOSE_TRACKED_KEYBOARD_MASKED_HANDS_FB`, update spec + version to 2. + ([internal MR 2270](https://gitlab.khronos.org/openxr/openxr/merge_requests/2270)) + - `XR_FB_passthrough`: add `XrPassthroughBrightnessContrastSaturationFB`, update + spec version to 2 + ([internal MR 2222](https://gitlab.khronos.org/openxr/openxr/merge_requests/2222)) + - `XR_FB_render_model`: Add capability support levels, bump spec version to 2. + ([internal MR 2264](https://gitlab.khronos.org/openxr/openxr/merge_requests/2264)) + - `XR_FB_space_warp`: Add + `XR_COMPOSITION_LAYER_SPACE_WARP_INFO_FRAME_SKIP_BIT_FB` into + `XrCompositionLayerSpaceWarpInfoFlagBitsFB`, update spec version to 2. + ([internal MR 2193](https://gitlab.khronos.org/openxr/openxr/merge_requests/2193)) + - `XR_HTC_vive_focus3_controller_interaction`: Support component path + "/input/squeeze/value", update spec version to 2. + ([internal MR 2253](https://gitlab.khronos.org/openxr/openxr/merge_requests/2253)) + - `XR_KHR_D3D11_enable` and `XR_KHR_D3D12_enable`: Update to describe error + conditions for `XR_ERROR_GRAPHICS_DEVICE_INVALID`. + ([internal MR 2176](https://gitlab.khronos.org/openxr/openxr/merge_requests/2176), + [internal issue 1617](https://gitlab.khronos.org/openxr/openxr/issues/1617)) + - `XR_MSFT_spatial_graph_bridge`: Update to revision 2. + ([internal MR 2182](https://gitlab.khronos.org/openxr/openxr/merge_requests/2182)) +- SDK + - Add `org.khronos.openxr.intent.category.IMMERSIVE_HMD` category to intent- + filter for `AndroidManifest.xml`, to indicate immersive application + ([internal MR 2219](https://gitlab.khronos.org/openxr/openxr/merge_requests/2219)) + - Common: Fix definitions in `xr_linear.h` so that it can be compiled as C or + C++. + ([internal MR 2217](https://gitlab.khronos.org/openxr/openxr/merge_requests/2217)) + - Fix warnings raised by Clang on various platforms. + ([internal MR 2197](https://gitlab.khronos.org/openxr/openxr/merge_requests/2197)) + - Fix source-generation script and codegen scripts to allow extension of KHR and + EXT enumerations with vendor-specific members. + ([internal MR 2240](https://gitlab.khronos.org/openxr/openxr/merge_requests/2240), + [internal MR 2243](https://gitlab.khronos.org/openxr/openxr/merge_requests/2243)) + - Fix warning print statement arguments in header generation/validation script. + ([internal MR 2244](https://gitlab.khronos.org/openxr/openxr/merge_requests/2244)) + - Loader: Adjust Android loader build to use the static C++ runtime, since we do + not expose any C++ interfaces. + ([OpenXR-SDK-Source PR 307](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/307), + [internal issue 1712](https://gitlab.khronos.org/openxr/openxr/issues/1712)) + - Remove "Draft" status accidentally left on the loader design doc/spec. + ([OpenXR-SDK-Source PR 300](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/300), + [internal issue 1688](https://gitlab.khronos.org/openxr/openxr/issues/1688)) + - Validation Layer: Functions that start with `xrTryCreate` will receive the same + warnings as functions that start with`xrCreate`. + ([internal MR 2182](https://gitlab.khronos.org/openxr/openxr/merge_requests/2182)) + - cmake: Install pkgconfig file in mingw + ([OpenXR-SDK-Source PR 308](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/308)) + - hello_xr: Shutdown OpenGL graphics to allow it to be restarted + ([internal MR 2241](https://gitlab.khronos.org/openxr/openxr/merge_requests/2241)) + - hello_xr: remove call to swapbuffers to fix OpenGL frame timing. + ([internal MR 2249](https://gitlab.khronos.org/openxr/openxr/merge_requests/2249)) + - hello_xr: Fix typo in declspec keyword + ([OpenXR-SDK-Source PR 302](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/302), + [internal issue 1691](https://gitlab.khronos.org/openxr/openxr/issues/1691)) + +## OpenXR SDK 1.0.22 (2022-01-12) + +This release features a number of new extensions, as well as some software +updates and fixes, especially for Android. If you are using the bundled jsoncpp, +this is also a security release as the bundled jsoncpp was upgraded to +incorporate security improvements from upstream. + +- Registry + - Add new `XR_FB_render_model` vendor extension. + ([internal MR 2117](https://gitlab.khronos.org/openxr/openxr/merge_requests/2117), + [internal MR 2169](https://gitlab.khronos.org/openxr/openxr/merge_requests/2169)) + - Add new `XR_HTC_facial_expression` vendor extension. + ([internal MR 2120](https://gitlab.khronos.org/openxr/openxr/merge_requests/2120)) + - Add new `XR_FB_keyboard_tracking` vendor extension. + ([internal MR 2128](https://gitlab.khronos.org/openxr/openxr/merge_requests/2128)) + - Add new `XR_EXT_uuid` multi-vendor extension. + ([internal MR 2152](https://gitlab.khronos.org/openxr/openxr/merge_requests/2152)) + - Add new `XR_FB_passthrough_keyboard_hands` vendor extension. + ([internal MR 2162](https://gitlab.khronos.org/openxr/openxr/merge_requests/2162)) + - Add new `XR_HTC_vive_focus3_controller_interaction` vendor extension. + ([internal MR 2178](https://gitlab.khronos.org/openxr/openxr/merge_requests/2178)) + - Add new `XR_ALMALENCE_digital_lens_control` vendor extension. + ([OpenXR-Docs PR 104](https://github.com/KhronosGroup/OpenXR-Docs/pull/104), + [internal issue 1615](https://gitlab.khronos.org/openxr/openxr/issues/1615)) + - Correct winding order for `XR_MSFT_hand_tracking_mesh` extension to clockwise + to match runtime behavior. + ([internal MR 2151](https://gitlab.khronos.org/openxr/openxr/merge_requests/2151)) + - Fix typos/naming convention errors in `XR_FB_hand_tracking_capsules`: rename + `XR_FB_HAND_TRACKING_CAPSULE_POINT_COUNT` to + `XR_HAND_TRACKING_CAPSULE_POINT_COUNT_FB` and + `XR_FB_HAND_TRACKING_CAPSULE_COUNT` to `XR_HAND_TRACKING_CAPSULE_COUNT_FB`, + providing the old names as compatibility aliases. + ([internal MR 1547](https://gitlab.khronos.org/openxr/openxr/merge_requests/1547), + [internal issue 1519](https://gitlab.khronos.org/openxr/openxr/issues/1519)) + - Reserve vendor extensions 208 - 299 for Facebook. + ([internal MR 2158](https://gitlab.khronos.org/openxr/openxr/merge_requests/2158)) + - Reserve extension numbers for anticipated multi-vendor extensions. + ([internal MR 2173](https://gitlab.khronos.org/openxr/openxr/merge_requests/2173)) +- SDK + - Android loader: Update vendored jnipp project, including crash/exception fixes + if an application manually attached or detached a thread. + ([OpenXR-SDK-Source PR 286](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/286), + [OpenXR-SDK-Source PR 285](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/285)) + - Docs: Fixed typo in docs. + ([OpenXR-SDK-Source PR 284](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/284)) + - Fix detection of std::filesystem options on GCC 11 and newer. + ([OpenXR-SDK-Source PR 276](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/276), + [OpenXR-SDK-Source issue 260](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/260), + [internal issue 1571](https://gitlab.khronos.org/openxr/openxr/issues/1571)) + - Loader: Add `ifdef` guards around contents of Android-specific files so all + platforms may still glob all source files in OpenXR-SDK to build the loader + with a custom build system. + ([OpenXR-SDK-Source PR 274](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/274)) + - Loader: Fixed incorrect return value when no broker is present on Android but + runtime defined via `active_runtime.json`. + ([OpenXR-SDK-Source PR 284](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/284)) + - Loader: Added `/system` to the search path on Android as per documentation. + ([OpenXR-SDK-Source PR 284](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/284)) + - Loader doc: Use `nativeLibraryDir` (property, part of API) instead of + `getNativeLibraryDir()` (function generated by wrapping library) + ([OpenXR-SDK-Source PR 278](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/278)) + - Update vendored copy of jsoncpp from 1.8.4 to 1.9.5 for security and other + fixes. + ([internal MR 2168](https://gitlab.khronos.org/openxr/openxr/merge_requests/2168), + [OpenXR-SDK-Source issue 265](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/265), + [internal issue 1582](https://gitlab.khronos.org/openxr/openxr/issues/1582)) + - Update android-jni-wrappers to fix missing include. + ([OpenXR-SDK-Source PR 280](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/280), + [OpenXR-SDK-Source issue 275](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/275), + [internal issue 1616](https://gitlab.khronos.org/openxr/openxr/issues/1616)) + - Update jnipp to fix crash on Android if app detaches thread from JVM (e.g. on + shutdown). + ([OpenXR-SDK-Source PR 280](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/280)) + - scripts: Populate `ext_name` in `HandleData` too, for use by language wrapper + generation scripts. + ([internal MR 2184](https://gitlab.khronos.org/openxr/openxr/merge_requests/2184)) + +## OpenXR SDK 1.0.21 (2022-01-10) + +This release was withdrawn due to a typo noticed after initial publication. +All changes are now listed under 1.0.22. + +## OpenXR SDK 1.0.20 (2021-10-04) + +This release includes a proposed cross-vendor OpenXR loader for Android, Android +build system for hello_xr, and a number of new vendor extensions. + +- Registry + - Add new `XR_HTCX_vive_tracker_interaction` provisional vendor extension. + ([internal MR 1983](https://gitlab.khronos.org/openxr/openxr/merge_requests/1983)) + - Add new `XR_VARJO_marker_tracking` vendor extension. + ([internal MR 2129](https://gitlab.khronos.org/openxr/openxr/merge_requests/2129)) + - Add new `XR_FB_triangle_mesh` vendor extension. + ([internal MR 2130](https://gitlab.khronos.org/openxr/openxr/merge_requests/2130)) + - Add new `XR_FB_passthrough` vendor extension. + ([internal MR 2130](https://gitlab.khronos.org/openxr/openxr/merge_requests/2130)) + - Reserve vendor extensions for Facebook. + ([internal MR 2131](https://gitlab.khronos.org/openxr/openxr/merge_requests/2131)) + - Reserve a vendor extension for Almalence. + ([OpenXR-Docs PR 99](https://github.com/KhronosGroup/OpenXR-Docs/pull/99)) + - XR_FB_color_space: Fix XML markup to indicate that + `XrSystemColorSpacePropertiesFB` is chained to `XrSystemProperties`. + ([internal MR 2143](https://gitlab.khronos.org/openxr/openxr/merge_requests/2143)) +- SDK + - Loader specification: Describe a cross-vendor loader for use on Android. + ([internal MR 1949](https://gitlab.khronos.org/openxr/openxr/merge_requests/1949), + [internal issue 1425](https://gitlab.khronos.org/openxr/openxr/issues/1425)) + - hello_xr: Add Android build system, using new cross-vendor loader, and make + some improvements/fixes. + ([internal MR 1949](https://gitlab.khronos.org/openxr/openxr/merge_requests/1949), + [internal issue 1425](https://gitlab.khronos.org/openxr/openxr/issues/1425)) + - loader: Implement cross-vendor loader for Android, with AAR Prefab packaging. + ([internal MR 1949](https://gitlab.khronos.org/openxr/openxr/merge_requests/1949), + [internal issue 1425](https://gitlab.khronos.org/openxr/openxr/issues/1425)) + +## OpenXR SDK 1.0.19 (2021-08-24) + +This release features a number of new or updated vendor extensions, as well as +some minor cleanups and bug fixes in the SDK. + +- Registry + - Add `XR_SESSION_NOT_FOCUSED` as a possible success return code to + `xrApplyHapticFeedback` and `xrStopHapticFeedback`. + ([internal MR 2106](https://gitlab.khronos.org/openxr/openxr/merge_requests/2106), + [internal issue 1270](https://gitlab.khronos.org/openxr/openxr/issues/1270)) + - Add new `XR_FB_hand_tracking_mesh` vendor extension. + ([internal MR 2089](https://gitlab.khronos.org/openxr/openxr/merge_requests/2089)) + - Add new `XR_FB_hand_tracking_capsules` vendor extension. + ([internal MR 2089](https://gitlab.khronos.org/openxr/openxr/merge_requests/2089)) + - Add new `XR_FB_hand_tracking_aim` vendor extension. + ([internal MR 2089](https://gitlab.khronos.org/openxr/openxr/merge_requests/2089)) + - Add version 1 of new `XR_FB_space_warp` vendor extension. + ([internal MR 2115](https://gitlab.khronos.org/openxr/openxr/merge_requests/2115)) + - Register new Author ID for Almalence. + ([OpenXR-Docs PR 92](https://github.com/KhronosGroup/OpenXR-Docs/pull/92), + [OpenXR-Docs PR 93](https://github.com/KhronosGroup/OpenXR-Docs/pull/93)) + - Update to version 2 of `XR_VALVE_analog_threshold`. + ([internal MR 2113](https://gitlab.khronos.org/openxr/openxr/merge_requests/2113)) +- SDK + - scripts: Some typing annotations and type-related cleanup found by using type- + aware Python editors. + ([internal MR 2100](https://gitlab.khronos.org/openxr/openxr/merge_requests/2100)) + - `xr_linear.h`: Fix bug in `XrVector3f_Cross` + ([internal MR 2111](https://gitlab.khronos.org/openxr/openxr/merge_requests/2111)) + +## OpenXR SDK 1.0.18 (2021-07-30) + +This release mostly adds new extensions. It also includes some fixes to the +included layers, as well as text in the loader documentation describing how +runtimes can register themselves for manual selection. This is not used by the +loader itself and does not require any changes to the loader, but it may be +useful to developer-focused supporting software. + +- Registry + - Add ratified `XR_KHR_swapchain_usage_input_attachment_bit` Khronos extension. + (Promotion of `XR_MND_swapchain_usage_input_attachment_bit`, which is now + deprecated.) + ([internal MR 2045](https://gitlab.khronos.org/openxr/openxr/merge_requests/2045)) + - Add new `XR_FB_foveation`, `XR_FB_foveation_configuration`, and + `XR_FB_foveation_vulkan` vendor extensions. + ([internal MR 2050](https://gitlab.khronos.org/openxr/openxr/merge_requests/2050)) + - Add additional extension dependencies to `XR_FB_swapchain_update_state`. + ([internal MR 2072](https://gitlab.khronos.org/openxr/openxr/merge_requests/2072), + [internal issue 1572](https://gitlab.khronos.org/openxr/openxr/issues/1572)) + - Add new `XR_FB_composition_layer_secure_content` vendor extension. + ([internal MR 2075](https://gitlab.khronos.org/openxr/openxr/merge_requests/2075)) + - Add new `XR_FB_composition_layer_alpha_blend` vendor extension. + ([internal MR 2078](https://gitlab.khronos.org/openxr/openxr/merge_requests/2078)) + - Add new `XR_FB_composition_layer_image_layout` vendor extension. + ([internal MR 2090](https://gitlab.khronos.org/openxr/openxr/merge_requests/2090)) + - Add new `XR_MSFT_spatial_anchor_persistence` vendor extension. + ([internal MR 2093](https://gitlab.khronos.org/openxr/openxr/merge_requests/2093)) + - Add some simple [Schematron](https://schematron.com) rules and a script to + check the XML registry against them. + ([internal MR 2103](https://gitlab.khronos.org/openxr/openxr/merge_requests/2103)) + - Register author ID and Reserve vendor extensions for Unity. + ([internal MR 2105](https://gitlab.khronos.org/openxr/openxr/merge_requests/2105)) + - Reserve extension ID range 187-196 for LIV Inc. + ([internal MR 2102](https://gitlab.khronos.org/openxr/openxr/merge_requests/2102)) +- SDK + - Describe how runtimes may register themselves at installation time for manual + selection. + ([internal MR 2081](https://gitlab.khronos.org/openxr/openxr/merge_requests/2081), + [internal MR 2109](https://gitlab.khronos.org/openxr/openxr/merge_requests/2109), + [internal issue 1574](https://gitlab.khronos.org/openxr/openxr/issues/1574)) + - Include sRGB in list of supported swapchain texture formats for the HelloXR + OpenGLES plugin. + ([internal MR 2066](https://gitlab.khronos.org/openxr/openxr/merge_requests/2066)) + - layers: Refactor generated `xrGetInstanceProcAddr` implementations to avoid + deeply-nested `if ... else` blocks. (Some compilers have limits we were nearing + or hitting.) + ([internal MR 2050](https://gitlab.khronos.org/openxr/openxr/merge_requests/2050)) + - validation layer: Set default logging mode to stdout ("text") instead of none. + ([OpenXR-SDK-Source PR 262](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/262)) + - validation layer: Fix invalid struct type error message to show the expected + type instead of the actual type. + ([OpenXR-SDK-Source PR 263](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/263)) + +## OpenXR SDK 1.0.17 (2021-06-08) + +This release features an important fix to the loader for an invalid-iterator bug +introduced in 1.0.16. All developers shipping the loader are strongly encouraged +to upgrade. It also includes a variety of new vendor extensions. + +- Registry + - Add `XR_MSFT_scene_understanding` vendor extension. + ([internal MR 2032](https://gitlab.khronos.org/openxr/openxr/merge_requests/2032)) + - Add `XR_MSFT_scene_understanding_serialization` vendor extension. + ([internal MR 2032](https://gitlab.khronos.org/openxr/openxr/merge_requests/2032)) + - Add `XR_MSFT_composition_layer_reprojection` vendor extension. + ([internal MR 2033](https://gitlab.khronos.org/openxr/openxr/merge_requests/2033)) + - Add `XR_OCULUS_audio_device_guid` vendor extension. + ([internal MR 2053](https://gitlab.khronos.org/openxr/openxr/merge_requests/2053)) + - Add version 3 of `XR_FB_swapchain_update_state` vendor extension, which splits + platform and graphics API specific structs into separate extensions. + ([internal MR 2059](https://gitlab.khronos.org/openxr/openxr/merge_requests/2059)) + - Apply formatting to registry XML by selectively committing changes made by + <https://github.com/rpavlik/PrettyRegistryXml>. + ([internal MR 2070](https://gitlab.khronos.org/openxr/openxr/merge_requests/2070), + [OpenXR-SDK-Source/#256](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/256)) + - Enforce that all `xrCreate` functions must be able to return + `XR_ERROR_LIMIT_REACHED` and `XR_ERROR_OUT_OF_MEMORY`, and adjust lists of + error codes accordingly. + ([internal MR 2064](https://gitlab.khronos.org/openxr/openxr/merge_requests/2064)) + - Fix a usage of `>` without escaping as an XML entity. + ([internal MR 2064](https://gitlab.khronos.org/openxr/openxr/merge_requests/2064)) + - Fix all cases of a success code (most often `XR_SESSION_LOSS_PENDING`) + appearing in the `errorcodes` attribute of a command. + ([internal MR 2064](https://gitlab.khronos.org/openxr/openxr/merge_requests/2064), + [internal issue 1566](https://gitlab.khronos.org/openxr/openxr/issues/1566)) + - Improve comments for several enum values. + ([internal MR 1982](https://gitlab.khronos.org/openxr/openxr/merge_requests/1982)) + - Perform some script clean-up and refactoring, including selective type + annotation and moving the Conventions abstract base class to `spec_tools`. + ([internal MR 2064](https://gitlab.khronos.org/openxr/openxr/merge_requests/2064)) + - Sort return codes, with some general, popular codes made to be early. Script + `sort_codes.py` can be used to maintain this, though it mangles other XML + formatting, so use it with care. <https://github.com/rpavlik/PrettyRegistryXml> + can format, and eventually sort return codes (currently sort order does not + match). + ([internal MR 2064](https://gitlab.khronos.org/openxr/openxr/merge_requests/2064), + [OpenXR-SDK-Source/#256](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/256)) +- SDK + - Loader: Fix iteration over explicit layer manifests. + ([OpenXR-SDK-Source/#256](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/256)) + - validation layer: Don't try to apply `strlen` to `wchar_t`-based output + buffers. + ([internal MR 2053](https://gitlab.khronos.org/openxr/openxr/merge_requests/2053)) + +## OpenXR SDK 1.0.16 (2021-05-11) + +This release contains an update to define a new error code, +`XR_ERROR_RUNTIME_UNAVAILABLE`, now returned by the loader at `xrCreateInstance` +and `xrEnumerateInstanceProperties` when it cannot find or load a runtime for +some reason. This should be more clear for developers when encountering it, as +well as helpful when troubleshooting errors hit by users. (The +previously-returned error was typically `XR_ERROR_INSTANCE_LOST`, which is +confusing when returned when trying to create an instance.) This release also +includes a new multi-vendor extension, a new vendor extension, and improved +concurrency handling in the loader, among smaller fixes. + +- Registry + - Add new `XR_ERROR_RUNTIME_UNAVAILABLE` error code, add + `XR_ERROR_RUNTIME_UNAVAILABLE` as a supported error code to `xrCreateInstance` + and `xrEnumerateInstanceProperties`, and remove `XR_ERROR_INSTANCE_LOST` as a + supported error code from `xrCreateInstance`. + ([internal MR 2024](https://gitlab.khronos.org/openxr/openxr/merge_requests/2024), + [internal issue 1552](https://gitlab.khronos.org/openxr/openxr/issues/1552), + [OpenXR-SDK-Source/#177](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/177)) + - Add `XR_EXT_hand_joint_motion_range` multi-vendor extension. + ([internal MR 1995](https://gitlab.khronos.org/openxr/openxr/merge_requests/1995)) + - Add `XR_FB_swapchain_update_state` vendor extension. + ([internal MR 1997](https://gitlab.khronos.org/openxr/openxr/merge_requests/1997)) + - Fix missing `XR_ERROR_INSTANCE_LOST` return codes for extension functions in + `XR_EXT_performance_settings`, `XR_EXT_debug_utils`, + `XR_EXT_conformance_automation`, and `XR_EXT_thermal_query`. + ([internal MR 2023](https://gitlab.khronos.org/openxr/openxr/merge_requests/2023), + [OpenXR-Docs/#10](https://github.com/KhronosGroup/OpenXR-Docs/issues/10), + [internal issue 1256](https://gitlab.khronos.org/openxr/openxr/issues/1256)) + - Reserve extension 166 for working group use. + ([internal MR 2025](https://gitlab.khronos.org/openxr/openxr/merge_requests/2025)) +- SDK + - Loader: Change runtime part to return `XR_ERROR_RUNTIME_UNAVAILABLE` when + there is an error loading a runtime. + ([internal MR 2024](https://gitlab.khronos.org/openxr/openxr/merge_requests/2024), + [internal issue 1552](https://gitlab.khronos.org/openxr/openxr/issues/1552), + [OpenXR-SDK-Source/#177](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/177)) + - Loader: Simplify in areas where code paths were dead. + ([internal MR 2024](https://gitlab.khronos.org/openxr/openxr/merge_requests/2024)) + - Loader: Improved locking around a few areas of the loader that aren't robust + against usual concurrent calls. + ([OpenXR-SDK-Source/#252](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/252)) + - validation layer: Fix generated code when a protected extension contains a base + header type. + ([internal MR 1997](https://gitlab.khronos.org/openxr/openxr/merge_requests/1997)) + +## OpenXR SDK 1.0.15 (2021-04-13) + +The main SDK change in this release is that the OpenXR headers **no longer +expose extension function prototypes** because extension functions are not +exported by the loader. This should prevent some confusion during development +without affecting code that correctly compiles and links with older SDKs. Code +that was compiled but not linked (for instance, the automated tests of example +source in the specification) and that would not have successfully linked may +have their defects highlighted by this change, however. If you need those +prototypes still available, there is a preprocessor define that can re-enable +them. The function pointer definitions are always available. + +In addition to that header change, this release contains three new vendor +extensions plus an assortment of SDK fixes. + +- Registry + - Add `XR_VARJO_foveated_rendering` vendor extension. + ([internal MR 1981](https://gitlab.khronos.org/openxr/openxr/merge_requests/1981)) + - Add `XR_VARJO_composition_layer_depth_test` vendor extension. + ([internal MR 1998](https://gitlab.khronos.org/openxr/openxr/merge_requests/1998)) + - Add `XR_VARJO_environment_depth_estimation` vendor extension. + ([internal MR 1998](https://gitlab.khronos.org/openxr/openxr/merge_requests/1998)) + - Add `uint16_t` to `openxr_platform_defines` (and associated scripts) so it may + be used easily by extensions. + ([internal MR 2017](https://gitlab.khronos.org/openxr/openxr/merge_requests/2017)) + - Reserve extension 149 for working group use. + ([internal MR 1999](https://gitlab.khronos.org/openxr/openxr/merge_requests/1999)) + - Reserve extension numbers 150 to 155 for ULTRALEAP extensions + ([internal MR 2006](https://gitlab.khronos.org/openxr/openxr/merge_requests/2006)) + - Reserve extension numbers 156-165 for Facebook. + ([internal MR 2018](https://gitlab.khronos.org/openxr/openxr/merge_requests/2018)) +- SDK + - Hide prototypes for extension functions unless explicitly requested by defining + `XR_EXTENSION_PROTOTYPES`. These functions are not exported from the loader, so + having their prototypes available is confusing and leads to link errors, etc. + ([OpenXR-SDK-Source/#251](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/251), + [OpenXR-SDK-Source/#174](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/174), + [internal issue 1554](https://gitlab.khronos.org/openxr/openxr/issues/1554), + [internal issue 1338](https://gitlab.khronos.org/openxr/openxr/issues/1338)) + - Also list API layers in list tool. + ([internal MR 1991](https://gitlab.khronos.org/openxr/openxr/merge_requests/1991)) + - Ensure we expose the OpenXR headers in the build-time interface of the loader, + as well as the install-time interface, for use with FetchContent.cmake. + ([OpenXR-SDK-Source/#242](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/242), + [OpenXR-SDK-Source/#195](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/195), + [internal issue 1409](https://gitlab.khronos.org/openxr/openxr/issues/1409)) + - Improve `BUILDING.md`, including adding details on how to specify architecture + for VS2019. + ([OpenXR-SDK-Source/#245](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/245), + [OpenXR-SDK-Source/#253](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/253)) + - Loader: Fix loader failing to load on Windows 7 due to `pathcch` dependency. + ([OpenXR-SDK-Source/#239](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/239), + [OpenXR-SDK-Source/#214](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/214), + [internal issue 1471](https://gitlab.khronos.org/openxr/openxr/issues/1471), + [OpenXR-SDK-Source/#236](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/236), + [internal issue 1519](https://gitlab.khronos.org/openxr/openxr/issues/1519)) + - Loader: Fix conflicting filename in `openxr_loader.def` causing a linker warning + when building debug for Windows. + ([OpenXR-SDK-Source/#246](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/246)) + - Update `cgenerator.py` to generate header comments in `openxr.h` to show when a + struct extends another struct + ([internal MR 2005](https://gitlab.khronos.org/openxr/openxr/merge_requests/2005)) + - hello_xr: Check for `shaderStorageImageMultisample` feature in Vulkan plugin + before using it. + ([OpenXR-SDK-Source/#234](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/234), + [OpenXR-SDK-Source/#233](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/233), + [internal issue 1518](https://gitlab.khronos.org/openxr/openxr/issues/1518)) + - hello_xr: Make sure `common.h` includes the reflection header that it uses. + ([OpenXR-SDK-Source/#247](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/247)) + - layers: Revise documentation, re-formatting and updating to refer to real + functions and URLs. + ([internal MR 2012](https://gitlab.khronos.org/openxr/openxr/merge_requests/2012)) + - loader: Check the instance handle passed to `xrGetInstanceProcAddr`. + ([internal MR 1980](https://gitlab.khronos.org/openxr/openxr/merge_requests/1980)) + - loader: Fix building OpenXR-SDK with CMake's multi-config Ninja generator. + ([OpenXR-SDK-Source/#249](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/249), + [OpenXR-SDK-Source/#231](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/231)) + - `openxr_reflection.h`: Make reproducible/deterministic by sorting protection + defines in the script. + ([internal MR 1993](https://gitlab.khronos.org/openxr/openxr/merge_requests/1993), + [internal issue 1424](https://gitlab.khronos.org/openxr/openxr/issues/1424)) + - xr_dependencies (shared utility): Include `unknwn.h` on Windows, even without + D3D enabled. + ([OpenXR-SDK-Source/#250](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/250), + [OpenXR-SDK-Source/#237](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/237)) + +## OpenXR SDK 1.0.14 (2021-01-27) + +This release contains a collection of fixes and improvements, including one new +vendor extension. Notably, we have relicensed all files that become part of the +loader, so the loader may be "Apache-2.0 OR MIT" for downstream license +compatibility. + +- Registry + - Add new `XR_FB_android_surface_swapchain_create` vendor extension. + ([internal MR 1939](https://gitlab.khronos.org/openxr/openxr/merge_requests/1939), + [internal issue 1493](https://gitlab.khronos.org/openxr/openxr/issues/1493), + [internal MR 1968](https://gitlab.khronos.org/openxr/openxr/merge_requests/1968)) + - Add missing `optional` attributes to `XR_KHR_vulkan_enable2` structs. Fixes + validation layer. + ([OpenXR-Docs/#72](https://github.com/KhronosGroup/OpenXR-Docs/pull/72)) + - Correction to `locationFlags` field in `XrHandJointLocationEXT` to be optional. + ([internal MR 1945](https://gitlab.khronos.org/openxr/openxr/merge_requests/1945)) + - Reserve vendor extensions for Varjo. + ([internal MR 1935](https://gitlab.khronos.org/openxr/openxr/merge_requests/1935)) + - Reserve vendor extensions for Magic Leap. + ([internal MR 1967](https://gitlab.khronos.org/openxr/openxr/merge_requests/1967), + [internal MR 1970](https://gitlab.khronos.org/openxr/openxr/merge_requests/1970)) + - Reserve extension number 143 to 148 for MSFT extensions. + ([internal MR 1969](https://gitlab.khronos.org/openxr/openxr/merge_requests/1969)) + - Update Magic Leap ID and contact information. + ([internal MR 1967](https://gitlab.khronos.org/openxr/openxr/merge_requests/1967)) +- SDK + - Add `./` to the start of the library name in API layer manifests on Windows, so + they are treated as a relative path. + ([internal MR 1975](https://gitlab.khronos.org/openxr/openxr/merge_requests/1975)) + - Fix searching for prerequisites in generated CMake config files. + ([internal MR 1963](https://gitlab.khronos.org/openxr/openxr/merge_requests/1963)) + - Start shipping the OpenXR API layers with the release artifacts. + ([internal MR 1975](https://gitlab.khronos.org/openxr/openxr/merge_requests/1975)) + - cmake: Debug library uses d suffix on Windows. CMake `OPENXR_DEBUG_POSTFIX` + variable can be set to something else to change it. + ([OpenXR-SDK-Source/#229](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/229)) + - hello_xr: Remove redundant call to `xrInitializeLoaderKHR`. + ([internal MR 1933](https://gitlab.khronos.org/openxr/openxr/merge_requests/1933)) + - hello_xr: Return supported sample count as 1 for GLES, GL and D3D11. + ([internal MR 1962](https://gitlab.khronos.org/openxr/openxr/merge_requests/1962)) + - hello_xr: Use `android.app.NativeActivity` correctly in place of NativeActivity + subclass. + ([internal MR 1976](https://gitlab.khronos.org/openxr/openxr/merge_requests/1976)) + - hello_xr: On Vulkan, explicitly add surface extensions for mirror window. + ([OpenXR-SDK-Source/#230](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/230), + [internal MR 1934](https://gitlab.khronos.org/openxr/openxr/merge_requests/1934)) + - loader: Relicense all files that become part of the loader, so the loader may + be "Apache-2.0 OR MIT" for downstream license compatibility. + ([internal MR 1937](https://gitlab.khronos.org/openxr/openxr/merge_requests/1937), + [internal issue 1449](https://gitlab.khronos.org/openxr/openxr/issues/1449), + [OpenXR-SDK-Source/#205](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/205)) + - loader: Protect against the application overriding loader symbols. + ([internal MR 1961](https://gitlab.khronos.org/openxr/openxr/merge_requests/1961)) + - loader: Handle JSON files in the search path that are not objects. + ([internal MR 1979](https://gitlab.khronos.org/openxr/openxr/merge_requests/1979)) + +## OpenXR SDK 1.0.13 (2020-11-24) + +The SDK in this release features some fixes to the loader's layer parsing: +upgrading is recommended. The hello_xr example has also been improved. The +registry for this release features a new ratified Khronos extension which will +serve as the basis of other extensions, as well as a number of new vendor +extensions. + +- Registry + - Add `XR_HTC_vive_cosmos_controller_interaction` vendor extension. + ([internal MR 1907](https://gitlab.khronos.org/openxr/openxr/merge_requests/1907)) + - Add `XR_FB_display_refresh_rate` vendor extension. + ([internal MR 1909](https://gitlab.khronos.org/openxr/openxr/merge_requests/1909)) + - Add `XR_MSFT_perception_anchor_interop` vendor extension. + ([internal MR 1929](https://gitlab.khronos.org/openxr/openxr/merge_requests/1929)) + - Added ratified `KHR_binding_modifications` Khronos extension. + ([internal MR 1878](https://gitlab.khronos.org/openxr/openxr/merge_requests/1878), + [internal issue 1413](https://gitlab.khronos.org/openxr/openxr/issues/1413)) + - Reserve vendor extensions for HTC. + ([internal MR 1907](https://gitlab.khronos.org/openxr/openxr/merge_requests/1907)) + - Reserve vendor extension numbers 109-120 for Facebook extensions. + ([internal MR 1913](https://gitlab.khronos.org/openxr/openxr/merge_requests/1913)) +- SDK + - Fix build errors under mingw-w64. + ([OpenXR-SDK-Source/#212](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/212)) + - Include PDB symbols to go along with the openxr_loader.dll Windows artifacts. + ([OpenXR-SDK-Source/#225](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/225)) + - `XrMatrix4x4f_CreateProjection`: Explicitly define matrix values as floats. + Prevents potential division by zero. + ([OpenXR-SDK-Source/#219](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/219)) + - build: Normalize how we detect and utilize threading libraries in the build + process. + ([internal MR 1910](https://gitlab.khronos.org/openxr/openxr/merge_requests/1910)) + - build: Search for OpenGL ES and other things needed on Android. + ([internal MR 1910](https://gitlab.khronos.org/openxr/openxr/merge_requests/1910)) + - build: Normalize how we detect and utilize Vulkan in the build process. + ([internal MR 1910](https://gitlab.khronos.org/openxr/openxr/merge_requests/1910)) + - build/ci: Have Windows loader artifacts organize themselves by + architecture/platform, and bundle the CMake config files and a "meta" CMake + config. + ([OpenXR-SDK-Source/#224](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/224), + [OpenXR-SDK-Source/#185](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/185)) + - documentation: Make API Layer manifest example for "disable_environment" and + "enable_environment" match the loader behavior + ([internal MR 1917](https://gitlab.khronos.org/openxr/openxr/merge_requests/1917), + [OpenXR-SDK-Source/#213](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/213)) + - hello_xr: Don't use subaction paths for quit_session action, it's unnecessary. + ([internal MR 1898](https://gitlab.khronos.org/openxr/openxr/merge_requests/1898)) + - hello_xr: Add initial build system support for building for Android. (No gradle + support yet.) + ([internal MR 1910](https://gitlab.khronos.org/openxr/openxr/merge_requests/1910)) + - hello_xr: Call `xrInitializeLoaderKHR` and dynamically load `openxr_loader` on + Android. + ([internal MR 1910](https://gitlab.khronos.org/openxr/openxr/merge_requests/1910)) + - hello_xr: Fix printing of action bindings and make it prettier. + ([internal MR 1914](https://gitlab.khronos.org/openxr/openxr/merge_requests/1914)) + - hello_xr: Fix break on Oculus Quest. + ([internal MR 1921](https://gitlab.khronos.org/openxr/openxr/merge_requests/1921)) + - hello_xr: The D3D12 and Vulkan graphics plugins sometimes did not update their + swapchain image context maps due to rare key collisions. + ([OpenXR-SDK-Source/#217](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/217)) + - loader: Stub in some preliminary code for Android loader support - not a + complete port. + ([internal MR 1910](https://gitlab.khronos.org/openxr/openxr/merge_requests/1910)) + - loader: Add Android logcat logger. + ([internal MR 1910](https://gitlab.khronos.org/openxr/openxr/merge_requests/1910)) + - loader: Fix parsing of XR_ENABLE_API_LAYERS environment variable + ([internal MR 1912](https://gitlab.khronos.org/openxr/openxr/merge_requests/1912)) + - loader: Fix issues around `xrInitializeLoaderKHR`. + ([internal MR 1922](https://gitlab.khronos.org/openxr/openxr/merge_requests/1922)) + - loader: Replace `#if _WIN32` with `#ifdef _WIN32`. + ([OpenXR-SDK-Source/#215](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/215)) + +## OpenXR SDK 1.0.12 (2020-09-25) + +This release features a number of new ratified KHR extensions, as well as a new +vendor extension. + +- Registry + - Add ratified `XR_KHR_vulkan_enable2` Khronos extension. + ([internal MR 1627](https://gitlab.khronos.org/openxr/openxr/merge_requests/1627), + [internal issue 1249](https://gitlab.khronos.org/openxr/openxr/issues/1249), + [internal issue 1283](https://gitlab.khronos.org/openxr/openxr/issues/1283), + [internal MR 1863](https://gitlab.khronos.org/openxr/openxr/merge_requests/1863)) + - Add ratified `XR_KHR_loader_init` Khronos extension. + ([internal MR 1744](https://gitlab.khronos.org/openxr/openxr/merge_requests/1744)) + - Add ratified `XR_KHR_loader_init_android` Khronos extension. + ([internal MR 1744](https://gitlab.khronos.org/openxr/openxr/merge_requests/1744)) + - Add ratified `XR_KHR_composition_layer_equirect2` Khronos extension. + ([internal MR 1746](https://gitlab.khronos.org/openxr/openxr/merge_requests/1746)) + - Add ratified `XR_KHR_composition_layer_color_scale_bias` Khronos extension. + ([internal MR 1762](https://gitlab.khronos.org/openxr/openxr/merge_requests/1762)) + - Add `XR_MSFT_controller_model` extension. + ([internal MR 1832](https://gitlab.khronos.org/openxr/openxr/merge_requests/1832)) + - Add vendor tag `LIV` for LIV Inc. + ([internal MR 1896](https://gitlab.khronos.org/openxr/openxr/merge_requests/1896)) + - Fix `structextends` attribute of `XrHandPoseTypeInfoMSFT`. + ([OpenXR-SDK-Source/#207](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/207)) + - schema: Update to permit aliases for commands and struct types. (Already + supported by tooling.) + ([internal MR 1627](https://gitlab.khronos.org/openxr/openxr/merge_requests/1627)) +- SDK + - cmake: fix openxr_loader target export when installing both Release and Debug + config on Windows. + ([OpenXR-SDK-Source/#206](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/206)) + - hello_xr: Support the new `XR_KHR_vulkan_enable2` extension. + ([internal MR 1627](https://gitlab.khronos.org/openxr/openxr/merge_requests/1627)) + - hello_xr: Use the `XR_KHR_loader_init_android` extension on Android. + ([internal MR 1903](https://gitlab.khronos.org/openxr/openxr/merge_requests/1903)) + - layers: Fix ARM builds by re-adding function attributes. + ([OpenXR-SDK-Source/#193](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/193)) +- Misc + - Clean up trailing whitespace, byte-order marks, anda ensure trailing newlines. + ([OpenXR-SDK-Source/#208](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/208)) + +## OpenXR SDK 1.0.11 (2020-08-14) + +This release is mainly for SDK improvements, with only small changes to the +docs. A new error code is provided for `xrCreateSession` for developers +convenience. + +- Registry + - Register `ULTRALEAP` author ID for Ultraleap. + ([internal MR 1877](https://gitlab.khronos.org/openxr/openxr/merge_requests/1877)) + - Reserve the extension number 98 to 101 for future MSFT extensions. + ([internal MR 1879](https://gitlab.khronos.org/openxr/openxr/merge_requests/1879)) + - schema: Distinguish `parentstruct` and `structextends` attributes in comments. + ([internal MR 1881](https://gitlab.khronos.org/openxr/openxr/merge_requests/1881), + [OpenXR-Docs/#51](https://github.com/KhronosGroup/OpenXR-Docs/issues/51), + [internal issue 1396](https://gitlab.khronos.org/openxr/openxr/issues/1396)) + - Add a new result code, `XR_ERROR_GRAPHICS_REQUIREMENTS_CALL_MISSING`, for + runtimes to return if `xrBeginSession` is called before calling one of the + `xrGetGraphicsRequirements` calls. + ([internal MR 1882](https://gitlab.khronos.org/openxr/openxr/merge_requests/1882), + [OpenXR-Docs/#53](https://github.com/KhronosGroup/OpenXR-Docs/issues/53), + [internal issue 1397](https://gitlab.khronos.org/openxr/openxr/issues/1397)) +- SDK + - Improve language usage in code and comments to be more respectful. + ([internal MR 1881](https://gitlab.khronos.org/openxr/openxr/merge_requests/1881)) + - Loader: Correct type of "extension_version" in API layer manifest files to + string, while maintaining backwards compatibility. Remove undocumented and + unused "device_extensions" and "entrypoints" keys. + ([internal MR 1867](https://gitlab.khronos.org/openxr/openxr/merge_requests/1867), + [internal issue 1411](https://gitlab.khronos.org/openxr/openxr/issues/1411)) + - Replace usage of `std::filesystem::canonical` with `PathCchCanonicalize` on + Windows platform to work around bug on UWP platforms. This also replaces + `PathCanonicalize` with `PathCchCanonicalize` and adds the appropriate library + for linking in. + ([OpenXR-SDK-Source/#198](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/198)) + - Support for building more projects when targeting UWP, and support for all + architectures when targeting Win32. + ([OpenXR-SDK-Source/#199](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/199)) + - hello_xr: fix Vulkan image layout transitions. + ([internal MR 1876](https://gitlab.khronos.org/openxr/openxr/merge_requests/1876)) + - validation: Enable three additional checks (on optional arrays with non- + optional counts) that were missing because of a script error. + ([internal MR 1881](https://gitlab.khronos.org/openxr/openxr/merge_requests/1881)) + +## OpenXR SDK 1.0.10 (2020-07-28) + +Note the relicensing of the registry XML file and some include files provided by +or generated by this repository (first item in each changelog section). Each +file's header, or an adjacent file with `.license` appended to the filename, is +the best reference for its license terms. We are currently working on ensuring +all files have an SPDX license identifier tag either in them or in an adjacent +file. This is still in progress but mostly complete. + +- Registry + - Relicense registry XML from MIT-like "Khronos Free Use License for Software and + Documentation" to, at your option, either the Apache License, Version 2.0, + found at + <http://www.apache.org/licenses/LICENSE-2.0>, or the MIT License, found at + <http://opensource.org/licenses/MIT>, for broader license compatibility with + downstream projects. (SPDX License Identifier expression "Apache-2.0 OR MIT") + ([internal MR 1814](https://gitlab.khronos.org/openxr/openxr/merge_requests/1814), + [OpenXR-Docs/#3](https://github.com/KhronosGroup/OpenXR-Docs/issues/3), + [internal issue 958](https://gitlab.khronos.org/openxr/openxr/issues/958)) + - Add `XR_MSFT_holographic_window_attachment` vendor extension. + ([internal MR 1833](https://gitlab.khronos.org/openxr/openxr/merge_requests/1833)) + - Add `XR_EXT_hp_mixed_reality_controller` multi-vendor extension. + ([internal MR 1834](https://gitlab.khronos.org/openxr/openxr/merge_requests/1834)) + - Add `XR_EXT_samsung_odyssey_controller` multi-vendor extension. + ([internal MR 1835](https://gitlab.khronos.org/openxr/openxr/merge_requests/1835)) + - Add `XR_VALVE_analog_threshold` vendor extension. + ([internal MR 1859](https://gitlab.khronos.org/openxr/openxr/merge_requests/1859)) + - Add `XR_MND_swapchain_usage_input_attachment_bit` vendor extension. + ([internal MR 1865](https://gitlab.khronos.org/openxr/openxr/merge_requests/1865)) + - Reserve extension numbers 71 to 78 for Facebook extensions. + ([internal MR 1839](https://gitlab.khronos.org/openxr/openxr/merge_requests/1839)) + - Reserve extension numbers 79 to 88 for Valve extensions. + ([internal MR 1842](https://gitlab.khronos.org/openxr/openxr/merge_requests/1842)) + - Reserve extension numbers 89 to 92 for Khronos extensions. + ([internal MR 1844](https://gitlab.khronos.org/openxr/openxr/merge_requests/1844)) + - Reserve extension numbers 93 to 94 for `EXT_unbounded_reference_space` and + `EXT_spatial_anchor`. + ([internal MR 1854](https://gitlab.khronos.org/openxr/openxr/merge_requests/1854)) + - `XR_EPIC_view_configuration_fov`: Fix `recommendedFov` incorrectly being named + `recommendedMutableFov`. This is a **source-incompatible change** to a vendor + extension. + ([internal MR 1812](https://gitlab.khronos.org/openxr/openxr/merge_requests/1812)) + - schema: Adjust to permit bitmask expansion in extensions, already supported by + toolchain thanks to Vulkan. + ([internal MR 1865](https://gitlab.khronos.org/openxr/openxr/merge_requests/1865)) + - scripts: Teach xml-consistency to handle bitmask values defined in extensions. + ([internal MR 1865](https://gitlab.khronos.org/openxr/openxr/merge_requests/1865)) +- SDK + - Relicense generated headers `openxr.h`, `openxr_platform.h`, + `openxr_reflection.h`, and static header `openxr_platform_defines.h` from the + Apache License, version 2.0, to, at your option, either the Apache License, + Version 2.0, found at + <http://www.apache.org/licenses/LICENSE-2.0>, or the MIT License, found at + <http://opensource.org/licenses/MIT>, for broader license compatibility with + downstream projects. (SPDX License Identifier expression "Apache-2.0 OR MIT") + ([internal MR 1814](https://gitlab.khronos.org/openxr/openxr/merge_requests/1814), + [OpenXR-Docs/#3](https://github.com/KhronosGroup/OpenXR-Docs/issues/3), + [internal issue 958](https://gitlab.khronos.org/openxr/openxr/issues/958)) + - Loader: Fix loading relative runtime libraries on Linux. + ([internal MR 1817](https://gitlab.khronos.org/openxr/openxr/merge_requests/1817)) + - Loader: Fix error on xrCreateInstance when explicitly trying to enable an + implicit API layer. + ([internal MR 1858](https://gitlab.khronos.org/openxr/openxr/merge_requests/1858)) + - Modify Azure DevOps build pipeline to automatically generate a NuGet package. + ([OpenXR-SDK-Source/#196](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/196)) + - Partially revert build system changes related to detecting Direct3D, to fix + builds. + ([internal MR 1802](https://gitlab.khronos.org/openxr/openxr/merge_requests/1802)) + - Portability fixes, including checking for `timespec_get` before enabling + `XR_USE_TIMESPEC`. + ([internal MR 1804](https://gitlab.khronos.org/openxr/openxr/merge_requests/1804)) + - cmake: export `OpenXRConfig.cmake` during install. Two targets can be imported + by another CMake application: `OpenXR::openxr_loader` and `OpenXR::headers`. + ([OpenXR-SDK-Source/#191](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/191), + [OpenXR-SDK-Source/#185](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/185)) + - hello_xr: Fix disparity between swapchain and render pass sample count in + Vulkan in the case where implementation recommends a value higher than one. + ([internal MR 1794](https://gitlab.khronos.org/openxr/openxr/merge_requests/1794)) + - hello_xr: Fix build on a minimal Linux install by ensuring we check for all + dependencies we use. We had missed checking for xcb_glx. + ([internal MR 1799](https://gitlab.khronos.org/openxr/openxr/merge_requests/1799), + [internal issue 1360](https://gitlab.khronos.org/openxr/openxr/issues/1360)) + - hello_xr: Fix a Vulkan crash on Windows related to the mirror window. + ([internal MR 1823](https://gitlab.khronos.org/openxr/openxr/merge_requests/1823)) + - hello_xr: Use more proper linear formats + ([internal MR 1840](https://gitlab.khronos.org/openxr/openxr/merge_requests/1840)) + - hello_xr: Enable use of glslangValidator to compile shaders if shaderc is not + available. + ([internal MR 1857](https://gitlab.khronos.org/openxr/openxr/merge_requests/1857)) + - hello_xr: Fix verbose per-layer information. + ([internal MR 1866](https://gitlab.khronos.org/openxr/openxr/merge_requests/1866)) + - hello_xr: Add Valve Index Controller bindings. Also use trigger value instead + of squeeze click for grab action on Vive Wand controller. + ([OpenXR-SDK-Source/#163](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/163)) + - openxr_reflection: Add `XR_LIST_STRUCT_` expansion macros for structure types, + as well as `XR_LIST_STRUCTURE_TYPES` macro associating types with + `XrStructureType` values. + ([internal MR 1495](https://gitlab.khronos.org/openxr/openxr/merge_requests/1495)) + - openxr_reflection: Adds `XR_LIST_EXTENSIONS()` macro, which will call your + supplied macro name with the name and extension number of all known extensions. + ([internal MR 1864](https://gitlab.khronos.org/openxr/openxr/merge_requests/1864)) + +## OpenXR SDK 1.0.9 (2020-05-29) + +- Registry + - Add an author ID, and reserve a vendor extension for Huawei. + ([OpenXR-Docs/#46](https://github.com/KhronosGroup/OpenXR-Docs/pull/46)) + - Reserve vendor extensions for future LunarG overlay and input focus + functionality. + ([internal MR 1720](https://gitlab.khronos.org/openxr/openxr/merge_requests/1720)) + - Reserve vendor extensions for Microsoft. + ([internal MR 1723](https://gitlab.khronos.org/openxr/openxr/merge_requests/1723)) + - Add `XR_EXT_hand_tracking` multi-vendor extension. + ([internal MR 1554](https://gitlab.khronos.org/openxr/openxr/merge_requests/1554), + [internal issue 1266](https://gitlab.khronos.org/openxr/openxr/issues/1266), + [internal issue 1267](https://gitlab.khronos.org/openxr/openxr/issues/1267), + [internal issue 1268](https://gitlab.khronos.org/openxr/openxr/issues/1268), + [internal issue 1269](https://gitlab.khronos.org/openxr/openxr/issues/1269)) + - Add `XR_HUAWEI_controller_interaction` vendor extension. + ([OpenXR-Docs/#47](https://github.com/KhronosGroup/OpenXR-Docs/pull/47)) + - Add `XR_MNDX_egl_enable` provisional vendor extension. + ([OpenXR-Docs/#48](https://github.com/KhronosGroup/OpenXR-Docs/pull/48)) + - Add `XR_MSFT_spatial_graph_bridge` vendor extension. + ([internal MR 1730](https://gitlab.khronos.org/openxr/openxr/merge_requests/1730)) + - Add `XR_MSFT_secondary_view_configuration` and `XR_MSFT_first_person_observer` + vendor extensions. + ([internal MR 1731](https://gitlab.khronos.org/openxr/openxr/merge_requests/1731)) + - Add `XR_MSFT_hand_mesh_tracking` vendor extension. + ([internal MR 1736](https://gitlab.khronos.org/openxr/openxr/merge_requests/1736)) + - Fix missing space in XML definition of `XrSpatialAnchorCreateInfoMSFT`. + ([internal MR 1742](https://gitlab.khronos.org/openxr/openxr/merge_requests/1742), + [internal issue 1351](https://gitlab.khronos.org/openxr/openxr/issues/1351), + [OpenXR-SDK-Source/#187](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/187)) + - Update a number of contacts for author/vendor tags. + ([internal MR 1788](https://gitlab.khronos.org/openxr/openxr/merge_requests/1788), + [internal issue 1326](https://gitlab.khronos.org/openxr/openxr/issues/1326)) +- SDK + - Replaced usage of the `_DEBUG` macro with `NDEBUG`. + ([internal MR 1756](https://gitlab.khronos.org/openxr/openxr/merge_requests/1756)) + - Allow disabling of `std::filesystem` usage via CMake, and detect if it's + available and what its requirements are. + ([OpenXR-SDK-Source/#192](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/192), + [OpenXR-SDK-Source/#188](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/188)) + - CI: Modifications to Azure DevOps build pipeline. Now builds UWP loader DLLs in + addition to Win32 loader DLLs. No longer builds static loader libraries due to + linkability concerns. Re-arranged release artifact zip to distinguish + architecture from 32-bit or 64-bit. + - Loader: Replace global static initializers with functions that return static + locals. With this change, code that includes OpenXR doesn't have to page in + this code and initialize these during startup. + ([OpenXR-SDK-Source/#173](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/173)) + - Loader: Unload runtime when `xrCreateInstance` fails. + ([internal MR 1778](https://gitlab.khronos.org/openxr/openxr/merge_requests/1778)) + - Loader: Add "info"-level debug messages listing all the places that we look for + the OpenXR active runtime manifest. + ([OpenXR-SDK-Source/#190](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/190)) + - Validation Layer: Fix crash in dereferencing a nullptr optional array handle + when the `count > 0`. + ([internal MR 1709](https://gitlab.khronos.org/openxr/openxr/merge_requests/1709), + [OpenXR-SDK-Source/#161](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/161), + [internal issue 1322](https://gitlab.khronos.org/openxr/openxr/issues/1322)) + - Validation Layer: Fix static analysis error and possible loss of validation + error. + ([internal MR 1715](https://gitlab.khronos.org/openxr/openxr/merge_requests/1715), + [OpenXR-SDK-Source/#160](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/160), + [internal issue 1321](https://gitlab.khronos.org/openxr/openxr/issues/1321)) + - Validation Layer: Simplify some generated code, and minor performance + improvements. + ([OpenXR-SDK-Source/#176](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/176)) + - API Dump Layer: Fix crash in dereferencing a `nullptr` while constructing a + `std::string`. + ([internal MR 1712](https://gitlab.khronos.org/openxr/openxr/merge_requests/1712), + [OpenXR-SDK-Source/#162](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/162), + [internal issue 1323](https://gitlab.khronos.org/openxr/openxr/issues/1323)) + - hello_xr: Fix releasing a swapchain image with the incorrect image layout. + ([internal MR 1755](https://gitlab.khronos.org/openxr/openxr/merge_requests/1755)) + - hello_xr: Prefer `VK_LAYER_KHRONOS_validation` over + `VK_LAYER_LUNARG_standard_validation` when available. + ([internal MR 1755](https://gitlab.khronos.org/openxr/openxr/merge_requests/1755)) + - hello_xr: Optimizations to D3D12 plugin to avoid GPU pipeline stall. + ([internal MR 1770](https://gitlab.khronos.org/openxr/openxr/merge_requests/1770)) + ([OpenXR-SDK-Source/#175](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/175)) + - hello_xr: Fix build with Vulkan headers 1.2.136. + ([OpenXR-SDK-Source/#181](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/181), + [OpenXR-SDK-Source/#180](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/180), + [internal issue 1347](https://gitlab.khronos.org/openxr/openxr/issues/1347)) + - hello_xr: Fix build with Visual Studio 16.6. + ([OpenXR-SDK-Source/#186](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/186), + [OpenXR-SDK-Source/#184](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/184)) + +## OpenXR SDK 1.0.8 (2020-03-27) + +Patch release for the 1.0 series. + +- Registry + - `XR_EXTX_overlay`: upgrade overlay bit names to match the convention, and + increase extension version number. This is a **source-incompatible change** to + a provisional multi-vendor extension. + ([internal MR 1697](https://gitlab.khronos.org/openxr/openxr/merge_requests/1697), + [internal issue 1318](https://gitlab.khronos.org/openxr/openxr/issues/1318), + [internal issue 42](https://gitlab.khronos.org/openxr/openxr/issues/42), + [internal MR 171](https://gitlab.khronos.org/openxr/openxr/merge_requests/171)) + - Introduce `XR_EXT_eye_gaze_interaction` extension for eye gaze interaction + profile. + ([internal MR 1556](https://gitlab.khronos.org/openxr/openxr/merge_requests/1556)) + - Add SPDX license identifier tag to registry schema. + ([internal MR 1686](https://gitlab.khronos.org/openxr/openxr/merge_requests/1686)) + - Add missing error codes to `xrCreateActionSet`, `xrCreateAction`, and + `xrGetInputSourceLocalizedName`. + ([internal MR 1698](https://gitlab.khronos.org/openxr/openxr/merge_requests/1698)) +- SDK + - Add SPDX license identifier tags to nearly all (code) files, including + generated files. + ([internal MR 1686](https://gitlab.khronos.org/openxr/openxr/merge_requests/1686)) + - Fix build system behavior with MSVC building in Release mode: only attempt + to copy PDB files if they exist. + ([internal MR 1701](https://gitlab.khronos.org/openxr/openxr/merge_requests/1701)) + +## OpenXR SDK 1.0.7 (2020-03-20) + +Patch release for the 1.0 series. + +Note: Changelogs are now being assembled with the help of the +[Proclamation](https://pypi.org/project/proclamation/) tool, so the format has +changed somewhat. + +- Registry + - Introduce `XR_MSFT_hand_interaction` extension for hand interaction profile. + ([internal MR 1601](https://gitlab.khronos.org/openxr/openxr/merge_requests/1601)) + - Introduce `XR_EPIC_view_configuration_fov` extension for system field-of-view + queries. + ([internal MR 1170](https://gitlab.khronos.org/openxr/openxr/merge_requests/1170)) + - Indicate that `xrBeginFrame` returns `XR_ERROR_CALL_ORDER_INVALID` when not + paired with a corresponding `xrWaitFrame` call. + ([internal MR 1673](https://gitlab.khronos.org/openxr/openxr/merge_requests/1673)) + - Update the version number of `XR_KHR_D3D12_enable` extension. + ([internal MR 1681](https://gitlab.khronos.org/openxr/openxr/merge_requests/1681)) + - Introduce `XR_EXTX_overlay` extension for Overlay sessions (which can + provide overlay composition layers). + ([internal MR 1665](https://gitlab.khronos.org/openxr/openxr/merge_requests/1665)) +- SDK + - loader: Add linker export map/version script to avoid exporting implementation + symbols from C++ on non-MSVC platforms. + ([internal MR 1641](https://gitlab.khronos.org/openxr/openxr/merge_requests/1641), + [OpenXR-SDK-Source/#159](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/159)) + - Add tracking and destruction of debug messengers in the loader. + ([internal MR 1668](https://gitlab.khronos.org/openxr/openxr/merge_requests/1668), + [OpenXR-SDK-Source/#29](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/29), + [internal issue 1284](https://gitlab.khronos.org/openxr/openxr/issues/1284)) + - Fix issue in `hello_xr` breaking the build in certain limited conditions. + ([OpenXR-SDK-Source/#170](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/170)) + - Add initial (partial) Android support for `hello_xr`. + ([internal MR 1680](https://gitlab.khronos.org/openxr/openxr/merge_requests/1680)) + - Fix a mismatched type signature, breaking compiles of hello_xr in at least some + Linux environments. + ([OpenXR-SDK-Source/#164](https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/164), + [internal MR 166](https://gitlab.khronos.org/openxr/openxr/merge_requests/166)) + - Explicitly link in `advapi32` for many of the APIs the loader uses on Windows, + needed when building for ARM/ARM64 (non-UWP only). + ([internal MR 1664](https://gitlab.khronos.org/openxr/openxr/merge_requests/1664)) + - Remove "Dev Build" string from loader resources and fix version. ([internal MR + 1664](https://gitlab.khronos.org/openxr/openxr/merge_requests/1664)) + - Add manual pages for `openxr_runtime_list` and `hello_xr` (based on their + `--help`), and install in the standard location on non-Windows platforms. + ([OpenXR-SDK-Source/#169](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/169)) + - Silence some noisy warnings in hello_xr and the layers. + ([OpenXR-SDK-Source/#165](https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/165)) + +## OpenXR 1.0.6 release (24-January-2020) + +Patch release for the 1.0 series. + +This release contains, among other things, a substantial simplification and +cleanup of the loader, which should fix a number of issues and also make it +forward compatible with extensions newer than the loader itself. As a part of +this change, the loader itself now only supports a single `XrInstance` active at +a time per process. If you attempt to create a new instance while an existing +one remains (such as in the case of application code leaking an `XrInstance` +handle), the loader will now return `XR_ERROR_LIMIT_REACHED`. + +### GitHub Pull Requests + +These had been integrated into the public repo incrementally. + +- hello_xr + - Initialize hand_scale to 1.0 + <https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/157> + - Fix Vulkan CHECK_CBSTATE build under newer MSVC + <https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/154> + - Initialize hand_scale to 1.0 to still show controller cubes even if + grabAction not available on startup. + <https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/157> +- Loader + - Single instance loader refactor with forward compatibility + <https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/146> (and internal + MRs 1599, 1621) + - Fix bug in loading API layers that could result in not loading an available + and enabled layer + <https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/155> +- Build + - Clean up linking, build loader and layers with all available + platform/presentation support, fix pkg-config file, rename `runtime_list` + test executable to `openxr_runtime_list` + <https://github.com/KhronosGroup/OpenXR-SDK-Source/pull/149> + +### Internal issues + +- Registry + - Fix typo in visibility mesh enum comment. + - Add `XR_EXT_win32_appcontainer_compatible` extension. +- Scripts + - Fix comment typos. + - Sync scripts with Vulkan. (internal MR 1625) +- Loader + - Allow use of `/` in paths in FileSysUtils on Windows. +- Build + - Improve messages +- hello_xr + - Add D3D12 graphics plugin (internal MR 1616) + - Fix comment typo. + +## OpenXR 1.0.5 release (6-December-2019) + +Patch release for the 1.0 series. + +This release primarily contains extension reservations and small specification +clarifications/fixes. + +### GitHub Pull Requests + +These had been integrated into the public repo incrementally. + +- Loader tests + - #147 - Small bugfix and output extension + +### Internal issues + +- Registry + - Reserve Microsoft extension numbers (Internal MR 1613) + +## OpenXR 1.0.4 release (21-November-2019) + +Patch release for the 1.0 series. + +This release includes some fixes, extensions, and a small build system change: +the build system is now configured to use C++14. No code changes in the loader +or layers have yet taken place that require C++14. **Please file an issue** in +OpenXR-SDK-Source if there is some deployment platform where you would be unable +to use a loader making use of C++14 features. + +### GitHub Pull Requests + +These had been integrated into the public repo incrementally. + +- General, Build, Other + - #141 - Support system libs better (permit system jsoncpp, etc. for easier + packaging) +- hello_xr + - #144 - Fix hello_xr when running under Linux OpenGL X11 +- Registry + - Reserve a Monado EGL extension + <https://github.com/KhronosGroup/OpenXR-Docs/pull/39> + +### Internal issues + +- General, Build, Other + - Switch C++ standard version to C++14 (internal MR 1602) + - Remove unused/unneeded files (internal MR 1609) +- Loader + - Fix typo in parameter/member names (internal MR 1607, internal issue 1233) + - Fix deprecated usage of JsonCpp (internal MR 1604, internal issue 1212) +- hello_xr + - Resolve misleading use of `xrLocateViews` before `xrWaitFrame` in helloXR + and spec (internal MR 1584, internal issue 1227, public issue + <https://github.com/KhronosGroup/OpenXR-SDK-Source/issues/134>) +- Registry + - Add `XR_EXT_conformance_automation` extension, for use **only** by + conformance testing (internal MR 1577, 1608) + +## OpenXR 1.0.3 release (7-October-2019) + +Patch release for the 1.0 series. + +Note that this release includes changes to adjust the symbol exports from +dynamic library versions of the loader to align with the specification. Only +**core** symbols are currently exported. All extension symbols must be retrieved +using `xrGetInstanceProcAddr`. + +### GitHub Pull Requests + +These had been integrated into the public repo incrementally. + +- General, Build, Other + - #139 - Write output atomically at the end of generator scripts + - #119 - Loader test updates. + - #116 - Static analysis cleanups. +- Loader + - #140 - Permit broader valid usage re: layers + - #133 - Remove shwapi dependency + - #132 - Fix directory searching for layers + - #130 - Fix exporting of symbols on Windows. + - #129 - Remove debug ext only when added by loader - fixes usage of debug ext + on runtimes that do not provide it themselves. + - #125 - Include a `OutputDebugString` logger for Win32 +- Layers + - #138 - Don't validate output enum buffer values + - #137 - Fix incorrect filenames in the generated API layer JSON + +### Internal issues + +- General, Build, Other + - Fix warnings in MSVC static code analysis mode (internal MR 1574) + - Validation layer improvements and fixes (internal MR 1568) + - Update vendored jsoncpp to 1.9.1 (internal MR 1523) +- Loader + - Add ability to quiet the loader's default output (internal MR 1576) + - Fix conformance of loader in + `xrEnumerateApiLayerProperties`/`xrEnumerateInstanceExtensionProperties` +- hello_xr + - Simplify action usage in hello_xr (internal MR 1553) +- Registry + - Add `XR_EXT_view_configuration_depth_range` extension (internal MR 1502, + internal issue 1201) + - Reserve a Monado extension (internal MR 1541) + +## OpenXR 1.0.2 release (27-August-2019) + +Patch release for the 1.0 series. + +Note that the loader on Windows has a **security fix**: All developers incorporating +the OpenXR loader should update immediately. + +### GitHub Pull Requests + +These had been integrated into the public repo incrementally. + +- General, Build, Other + - #112 - Update active runtime search documentation + - #106 - List app changes + - #114 - Support for building WindowsStore loader and layers, and simplified + filename + - #96 - Misc cleanup: build simplification, install hello_xr, + allow building as subproject, fix null deref in validation layer. +- Loader + - #102 - Default to catching exceptions, since not being able to catch + (and having a non-throwing standard library) is less common + - #109 - Factor out some debug-utils related code from the loader, + and migrate validation layer to that shared code. + - #108 - Update json_stream initialization to improve compatibility + - #118 - Fix logic error in Linux active runtime search + - #115, #117 - Simplification and refactoring. +- Layers + - #111 - Some fixes to Validation Layer (as found applying to the UE4 OpenXR + plugin) + - #110 - Fix cleaning up session labels in validation layer +- From OpenXR-Docs: + - #26 - Proposal for unbounded space and spatial anchor extensions (vendor + extensions) + +### Internal issues + +- General, Build, Other + - Allow project to be included in a parent project. (Internal MR 1512) +- hello_xr + - Fix OpenGL version number to be XrVersion. (Internal MR 1515) + - Make D3D11 debug device handling more friendly. (Internal MR 1504) +- Registry + - Fix error in extension-added function. (Internal MR 1510) + - Add Oculus Android extension. (Internal MR 1518) + - Reserve additional extension number for Oculus. (Internal MR 1517) +- Loader + - **Security fix**: Do not use HKEY_CURRENT_USER or environment variables when + the process is running higher than medium-integrity on Windows. + (Internal issue 1205, internal MR 1511) + - Small updates to the loader documentation. + +### New extension + +- `XR_OCULUS_android_session_state_enable` + +## OpenXR 1.0.1 release (2-August-2019) + +Patch release for the 1.0 series. + +### GitHub Pull Requests + +These had been integrated into the public repo incrementally. + +- General, Build, Other + - #87 - Fix makefiles + - #88 - Remove unneeded generation (corresponds to issue #74, internal issue + 1139, internal MR 1491) + - #101 - Fix install of header and loader. +- Loader + - #91 - Fix a loader bug which prevented Layers from not implementing all XR + functions + - #95 - Guard config includes/defines (relates to #81, #92) + - #97 - Remove a constant static std::vector, use a std::array instead. +- Layers + - #84 - Fix Linux warning for apidump +- From OpenXR-Docs: + - #26 - Proposal for unbounded space and spatial anchor extensions (vendor + extensions) + +### Internal issues + +- General, Build, Other + - Makefile cleanups (internal MR 1469, 1489) + - Add release scripts (internal MR 1496) +- Registry + - Reserve Oculus extension numbers (internal MR 1493) + - Add Monado headless (vendor extension) (internal MR 1482) +- Loader + - Remove unnecessary `#ifdef _WIN32` in loader. (internal MR 1487) + +### New extensions + +- `XR_MND_headless` +- `XR_MSFT_spatial_anchor` +- `XR_MSFT_unbounded_reference_space` + +## OpenXR 1.0.0 release (29-July-2019) + +Incorporates spec changes from OpenXR 1.0, +all public pull requests incorporated in the 0.90 series, +and additional fixes and improvements not previously published. + +## Change log for OpenXR 0.90 provisional spec updates post-0.90.1 + +### GitHub Pull Requests + +These had been integrated into the public repo incrementally. + +- General, Build, Other + - #40 - Update BUILDING.md with some Linux pre-requisites + - #43 - Make manifest file more compatible + - #44 - Remove pkg-config dependency from xlib backend + - #46 - Support building with "embedded" Python + - #48 - Install layers and pkg-config file on Linux + - #66 - Install the layers libraries on Linux + - #71 - Validation layer: fix logic error +- hello_xr + - #49 - Fix hello_xr to properly use two call idiom +- Loader + - #38 - Remove dead file-locking code + - #51 - Idiomatic Linux active_runtime.json search logic + - #55, #58, #68 - Purge std::map bracket operations that might do inadvertent + insertions + - #56 - Make `filesystem_util.cc` `#define UNICODE`-compatible + - #57 - Make it possible to bypass macro that checks which `filesystem` to use + - #60 - Fix build error with shlwapi function + - #62 - Don't limit contents of `XristanceCreateInfo` next chain + - #65 - Fix minor substr error + - #69 - Simplify loader + - #70, #76 - Make loader exception free + - #72 - filesystem: fix theoretical bug on Linux + - #73 - Loader proper UNICODE support + - #75 - Clang tidy + - #80 - Switchable exceptions + - #82 - Add folder properties to all CMake targets. + +## Change log for OpenXR 0.90.1 provisional spec update (8-May-2019) + +No API changes, and only minimal consistency changes to the spec/registry. +Mostly an update for tooling, layers, loader, and sample code. Header version +has been bumped to 43, but no symbols that should have actually been in use have +changed. + +### GitHub Pull Requests + +These had been integrated into the public repo incrementally. + +- General, Build, Other + - #8, #11, #12 - Improve BUILDING and README + - #9 - Make Vulkan SDK dependency optional + - #17 - Add install target to CMake files + - #17 - API dump layer, build: timespec extension fixes + - #19 - build: fix CMAKE_PRESENTATION_BACKEND default on linux + - #34 - list: Fix list test output +- validation layer + - #18, #22, #23 - Fix build and execution + - #24 - Fix crash and refactor +- hello_xr + - #13 - Do not query GL context API version before creating context + - #26 - Fix a warning +- Loader + - #3 - Don't cross 32/64 registry silos + - #14 - Initialize XrExtensionProperties array parameter for + rt_xrEnumerateInstanceExtensionProperties + - #20 - Fix Linux manifest file search + - #30 - Add default implementations of API functions to dispatch chains + - #32 - Avoid crash when evaluating layer disable environment vars + - #35 - Add 'unknown' strings to loader's *ToString fallback functions + - #36 - Allow null instance in xrGetInstanceProcAddr() for certain entry + points + - #39 - Default to static loader only on Windows + +### Internal Issues + +- General, Build, Other + - Unify (for the most part) the OpenXR and Vulkan generator scripts. (internal + MR 1166) + - List instance extensions in the "list" test. (internal MR 1169) + - Avoid dllexport for all apps compiled with `openxr_platform_defines.h` + (internal MR 1187) + - Don't offer `BUILD_SPECIFICATION` unless the spec makefile is there. + (internal MR 1179) + - Add simple input example to hello_xr. (internal MR 1178) + - Add a clang-format script for ease of development. +- API Registry and Headers + - Remove impossible and undocumented error codes. (internal MR 1185 and 1189) + - Mark layers in `XrFrameEndInfo` as optional. (internal MR 1151, internal + issue 899) + - Remove unused windows types from `openxr_platform.h` (internal MR 1197) + - Make `openxr_platform.h` include `openxr.h` on which it depends. (internal + MR 1140, internal issue 918) + - Remove unused, undocumented defines. (internal MR 1238, internal issue 1012) +- Loader + - Fix loader regkey search logic so 64bit application loads 64bit regkey + value. (internal MR 1180) + - Modify loader to be friendly to UWP (Universal Windows Platform) build + target. (internal MR 1198) + +## OpenXR 0.90.0 - Initial public provisional release at GDC diff --git a/shadps4-arm64-main/externals/openxr-sdk/CMakeLists.txt b/shadps4-arm64-main/externals/openxr-sdk/CMakeLists.txt new file mode 100644 index 0000000..9ab16e2 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/CMakeLists.txt @@ -0,0 +1,208 @@ +# Copyright (c) 2017-2026 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Note: This is the top-level CMake file for the OpenXR project. +# It should contain only definitions that are applicable to the +# entire project and includes for the sub-directories. + +cmake_minimum_required(VERSION 3.16) +project(OPENXR) + +find_package(Python3 COMPONENTS Interpreter) +include(CTest) + +# Enable IDE GUI folders. "Helper targets" that don't have interesting source code should set their FOLDER property to this +set_property(GLOBAL PROPERTY USE_FOLDERS ON) +set_property( + GLOBAL PROPERTY PREDEFINED_TARGETS_FOLDER "CMake predefined targets" +) +set(LOADER_FOLDER "Loader") +set(HELPER_FOLDER "Helpers") +set(CODEGEN_FOLDER "Generated") +set(TESTS_FOLDER "Tests") +set(CONFORMANCE_TESTS_FOLDER "Conformance Test Suite") +set(LOADER_TESTS_FOLDER "Loader Tests") +set(API_LAYERS_FOLDER "Layers") +set(SAMPLES_FOLDER "Samples") + +option( + BUILD_FORCE_GENERATION + "Force re-generation of files even in the presence of pre-generated copies, replacing those copies." + OFF +) + +if(BUILD_FORCE_GENERATION AND NOT Python3_EXECUTABLE) + message(FATAL_ERROR "BUILD_FORCE_GENERATION requires Python") +endif() + +if(MSVC) + option( + INSTALL_SYMBOLS + "Install the .pdb debug symbols, if applicable, when installing binaries" + ON + ) +endif() + +string(TOUPPER "${CMAKE_GENERATOR_PLATFORM}" CMAKE_GENERATOR_PLATFORM_UPPER) + +# Artifact organization +if(WIN32 OR ANDROID) + option( + INSTALL_TO_ARCHITECTURE_PREFIXES + "Install platform-specific files to architecture-specific directories, for packaging" + OFF + ) +endif() + +if(WIN32 AND INSTALL_TO_ARCHITECTURE_PREFIXES) + unset(_UWP_SUFFIX) + if(CMAKE_SYSTEM_NAME STREQUAL "WindowsStore") + set(_UWP_SUFFIX _uwp) + endif() + if(CMAKE_GENERATOR_PLATFORM_UPPER MATCHES "ARM.*") + if(CMAKE_SIZEOF_VOID_P EQUAL 8) + set(_PLATFORM ARM64) + else() + set(_PLATFORM ARM) + endif() + else() + if(CMAKE_SIZEOF_VOID_P EQUAL 8) + set(_PLATFORM x64) + else() + set(_PLATFORM Win32) + endif() + endif() + + include(GNUInstallDirs) + set(CMAKE_INSTALL_BINDIR ${_PLATFORM}${_UWP_SUFFIX}/${CMAKE_INSTALL_BINDIR}) + set(CMAKE_INSTALL_LIBDIR ${_PLATFORM}${_UWP_SUFFIX}/${CMAKE_INSTALL_LIBDIR}) + +elseif(ANDROID AND INSTALL_TO_ARCHITECTURE_PREFIXES) + # This organizes things like a prefab module + set(PREFAB_INSTALL_DIR prefab) + set(PREFAB_HEADER_MODULE_INSTALL_DIR + "${PREFAB_INSTALL_DIR}/modules/headers" + ) + set(PREFAB_LOADER_MODULE_INSTALL_DIR + "${PREFAB_INSTALL_DIR}/modules/openxr_loader" + ) + set(CMAKE_INSTALL_LIBDIR + "${PREFAB_LOADER_MODULE_INSTALL_DIR}/libs/android.${ANDROID_ABI}" + CACHE STRING "Where to install libraries" + ) + set(CMAKE_INSTALL_BINDIR ${CMAKE_INSTALL_LIBDIR}) + set(CMAKE_INSTALL_INCLUDEDIR ${PREFAB_HEADER_MODULE_INSTALL_DIR}/include) + + unset(NDK_MAJOR_VERSION) + if(CMAKE_ANDROID_NDK) + file(STRINGS "${CMAKE_ANDROID_NDK}/source.properties" NDK_PROPERTIES) + foreach(_line ${NDK_PROPERTIES}) + if("${_line}" MATCHES + "Pkg.Revision = ([0-9]+)[.]([0-9]+)[.]([0-9]+)" + ) + set(NDK_MAJOR_VERSION ${CMAKE_MATCH_1}) + endif() + endforeach() + else() + message(FATAL_ERROR "Please set CMAKE_ANDROID_NDK to your NDK root!") + endif() + if(NDK_MAJOR_VERSION) + message(STATUS "Building using NDK major version ${NDK_MAJOR_VERSION}") + else() + message( + FATAL_ERROR + "Could not parse the major version from ${CMAKE_ANDROID_NDK}/source.properties" + ) + endif() + +else() + include(GNUInstallDirs) +endif() + +# Path separators ( : or ; ) are not handled well in CMake. +# This seems like a reasonable approach. +if(CMAKE_HOST_SYSTEM_NAME STREQUAL Windows) + set(CODEGEN_PYTHON_PATH + "${PROJECT_SOURCE_DIR}/specification/scripts;${PROJECT_SOURCE_DIR}/src/scripts;$ENV{PYTHONPATH}" + ) +else() + set(CODEGEN_PYTHON_PATH + "${PROJECT_SOURCE_DIR}/specification/scripts:${PROJECT_SOURCE_DIR}/src/scripts:$ENV{PYTHONPATH}" + ) +endif() + +add_subdirectory(include) +add_subdirectory(src) + +# uninstall target +if(NOT TARGET uninstall) + configure_file( + src/cmake/cmake_uninstall.cmake.in + "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" + IMMEDIATE + @ONLY + ) + add_custom_target( + uninstall + COMMAND + ${CMAKE_COMMAND} -P + ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake + ) + set_target_properties(uninstall PROPERTIES FOLDER ${HELPER_FOLDER}) +endif() + +find_program(BASH_COMMAND NAMES bash) +if(BASH_COMMAND AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/specification/Makefile") + option( + BUILD_SPECIFICATION + "Run './makeAllExts all' in the specification directory as part of the build - intended for one-step checking of spec changes" + OFF + ) + if(BUILD_SPECIFICATION) + add_custom_target( + spec-all ALL + "${BASH_COMMAND}" ./makeAllExts all + WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/specification" + VERBATIM + COMMENT "Running './makeAllExts all' in the specification directory" + USES_TERMINAL + ) + endif() +endif() + +if(ANDROID AND INSTALL_TO_ARCHITECTURE_PREFIXES) + set(LICENSE_DEST META-INF) +else() + set(LICENSE_DEST share/doc/openxr) +endif() + +if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE") + install( + FILES "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE" + DESTINATION ${LICENSE_DEST} + COMPONENT License + ) +elseif(EXISTS "${CMAKE_SOURCE_DIR}/../../../../LICENSES/Apache-2.0.txt") + # Building from a sources jar, where we omit that single file + # to avoid confusion regarding the combination of licenses in the sources. + # But for consistency, we will put it in the binaries. + install( + FILES "${CMAKE_SOURCE_DIR}/../../../../LICENSES/Apache-2.0.txt" + RENAME LICENSE + DESTINATION ${LICENSE_DEST} + COMPONENT License + ) +endif() diff --git a/shadps4-arm64-main/externals/openxr-sdk/CODE_OF_CONDUCT.md b/shadps4-arm64-main/externals/openxr-sdk/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..287a363 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/CODE_OF_CONDUCT.md @@ -0,0 +1,12 @@ + +<!-- +Copyright (c) 2014-2026 The Khronos Group Inc. + +SPDX-License-Identifier: CC-BY-4.0 +--> + +A reminder that this issue tracker is managed by the Khronos Group. +Interactions here should follow the Khronos Code of Conduct +([https://www.khronos.org/developers/code-of-conduct](https://www.khronos.org/developers/code-of-conduct)), +which prohibits aggressive or derogatory language. +Please keep the discussion friendly and civil. diff --git a/shadps4-arm64-main/externals/openxr-sdk/COPYING.adoc b/shadps4-arm64-main/externals/openxr-sdk/COPYING.adoc new file mode 100644 index 0000000..fbf15d9 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/COPYING.adoc @@ -0,0 +1,123 @@ += COPYING.adoc for the Khronos Group OpenXR projects + +// Copyright (c) 2020-2026 The Khronos Group Inc. +// +// SPDX-License-Identifier: CC-BY-4.0 + +This document is shared across a number of OpenXR GitHub projects, as the +set of files in those projects is partially overlapping. +(There is a single "source of truth" internal Khronos GitLab monorepo these +GitHub repositories interact with.) + +== Licenses + +The OpenXR GitHub projects use several licenses. +In general, we work to maintain compliance with the +https://reuse.software/spec/[REUSE 3.0 specification] with clear copyright +holders and license identifier listed for each file, preferably in each +file. +Where this is not possible, or e.g. when we are using files unmodified from +other open source projects, license data is listed: + +* in an adjacent file of the same name, with the additional extension + "`.license`" +* in the repository-wide "`.reuse/dep5`" copyright description + https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/["DEP5" + machine-readable copyright data] file. + +The https://github.com/fsfe/reuse-tool["`reuse`" command line tool] can be +used to create a software bill of materials in SPDX format from this data. +Note that this tool will typically exclude the generated files, so if the +BOM is important to you, you may consider using the +https://github.com/KhronosGroup/OpenXR-SDK[OpenXR-SDK] repository that +contains the API headers and the loader source with all generated files +pre-generated. + +The data in/adjacent to each file is the authoritative license and copyright +data. +However, for ease of understanding, the following general practices can be +observed. +(If in doubt, or if the following summary conflicts with the per-file data, +the per-file data remains authoritative.) + +* The source files (in asciidoctor and other formats) for the OpenXR + Specification, reference pages, and supporting documentation are licensed + under the Creative Commons Attribution 4.0 International License (SPDX + license identifier "`CC-BY-4.0`"). +* Header files, scripts, programs, XML files, and other tooling used or + generated as part of the build process is licensed under the Apache + License, Version 2.0. +* For compatibility with external developers working in GPLed projects who + have requested it, the main OpenXR headers, XML registry, and loader + source are licensed under a dual license with the SPDX license identifier + "`Apache-2.0 OR MIT`" . + Relevant files include: +** "`specification/registry/xr.xml`" +** "`include/openxr/openxr_platform_defines.h`" +** The generated OpenXR headers "`openxr.h`", "`openxr_platform.h`", and + "`openxr_reflection.h`". +** Source files in "`src/loader/`", and a few files in "`src/common/`". +** Generated source files used by the loader (including pre-generated in + OpenXR-SDK): "`common_config.h`", "`xr_generated_loader.cpp`", and + "`xr_generated_loader.hpp`". +* There are a few files adopted from other open source projects. + Such files continue under their original licenses, and appropriately + annotated in accordance with REUSE. +* Some generated, transient files produced during the course of building the + specification, headers, or other targets may not have copyrights. + These are typically very short asciidoc fragments describing parts of the + OpenXR API, and are incorporated by reference into specification or + reference page builds. + +Users outside Khronos who create and post OpenXR Specifications, whether +modified or not, should use the CC-BY-4.0 license on the output documents +(HTML, PDF, etc.) they generate. + + +== Frequently Asked Questions + +Q: Why are the HTML and PDF Specifications posted on Khronos' website under +a license which is neither CC-BY-4.0 nor Apache 2.0? + +A: The Specifications posted by Khronos in the OpenXR Registry are licensed +under the proprietary Khronos Specification License. +Only these Specifications are Ratified by the Khronos Board of Promoters, +and therefore they are the only Specifications covered by the Khronos +Intellectual Property Rights Policy. + + +Q: Does Khronos allow the creation and distribution of modified versions of +the OpenXR Specification, such as translations to other languages? + +A: Yes. +Such modified Specifications, since they are not created by Khronos, should +be placed under the CC-BY-4.0 license. +If you believe your modifications are of general interest, consider +contributing them back by making a pull request (PR) on the OpenXR-Docs +project. + + +Q: Can I contribute changes to the OpenXR Specification? + +A: Yes, by opening an Issue or Pull Request (PR) on the +link:https://github.com/KhronosGroup/OpenXR-Docs/[OpenXR-Docs] GitHub +project. +You must execute a click-through Contributor License Agreement, which brings +your changes under the umbrella of the Khronos IP policy. + + +Q: Can you change the license on your files so they're compatible with my +license? + +A: We are using a dual license license on `xr.xml`, the main API headers, +and the loader source files, to make them compatible with GPL-2.0- and +LGPL-2.0/2.1-licensed projects. +This replaces earlier approaches of an MIT-like license on the XML and +Apache 2.0 on all headers, and allows use of the SPDX license identifier +"`Apache-2.0 OR MIT`" to denote the license. + +If you *require* this same compatibility for use of other Apache-2.0 +licensed files in our repository, please raise an issue identifying the +files and we will consider changing those specific files to the dual license +as well. + diff --git a/shadps4-arm64-main/externals/openxr-sdk/LICENSE b/shadps4-arm64-main/externals/openxr-sdk/LICENSE new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/shadps4-arm64-main/externals/openxr-sdk/LICENSES/Apache-2.0.txt b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/Apache-2.0.txt new file mode 100644 index 0000000..527a83a --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/Apache-2.0.txt @@ -0,0 +1,208 @@ +Apache License + +Version 2.0, January 2004 + +http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, +AND DISTRIBUTION + + 1. Definitions. + + + +"License" shall mean the terms and conditions for use, reproduction, and distribution +as defined by Sections 1 through 9 of this document. + + + +"Licensor" shall mean the copyright owner or entity authorized by the copyright +owner that is granting the License. + + + +"Legal Entity" shall mean the union of the acting entity and all other entities +that control, are controlled by, or are under common control with that entity. +For the purposes of this definition, "control" means (i) the power, direct +or indirect, to cause the direction or management of such entity, whether +by contract or otherwise, or (ii) ownership of fifty percent (50%) or more +of the outstanding shares, or (iii) beneficial ownership of such entity. + + + +"You" (or "Your") shall mean an individual or Legal Entity exercising permissions +granted by this License. + + + +"Source" form shall mean the preferred form for making modifications, including +but not limited to software source code, documentation source, and configuration +files. + + + +"Object" form shall mean any form resulting from mechanical transformation +or translation of a Source form, including but not limited to compiled object +code, generated documentation, and conversions to other media types. + + + +"Work" shall mean the work of authorship, whether in Source or Object form, +made available under the License, as indicated by a copyright notice that +is included in or attached to the work (an example is provided in the Appendix +below). + + + +"Derivative Works" shall mean any work, whether in Source or Object form, +that is based on (or derived from) the Work and for which the editorial revisions, +annotations, elaborations, or other modifications represent, as a whole, an +original work of authorship. For the purposes of this License, Derivative +Works shall not include works that remain separable from, or merely link (or +bind by name) to the interfaces of, the Work and Derivative Works thereof. + + + +"Contribution" shall mean any work of authorship, including the original version +of the Work and any modifications or additions to that Work or Derivative +Works thereof, that is intentionally submitted to Licensor for inclusion in +the Work by the copyright owner or by an individual or Legal Entity authorized +to submit on behalf of the copyright owner. For the purposes of this definition, +"submitted" means any form of electronic, verbal, or written communication +sent to the Licensor or its representatives, including but not limited to +communication on electronic mailing lists, source code control systems, and +issue tracking systems that are managed by, or on behalf of, the Licensor +for the purpose of discussing and improving the Work, but excluding communication +that is conspicuously marked or otherwise designated in writing by the copyright +owner as "Not a Contribution." + + + +"Contributor" shall mean Licensor and any individual or Legal Entity on behalf +of whom a Contribution has been received by Licensor and subsequently incorporated +within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of this +License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, +no-charge, royalty-free, irrevocable copyright license to reproduce, prepare +Derivative Works of, publicly display, publicly perform, sublicense, and distribute +the Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of this License, +each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, +no-charge, royalty-free, irrevocable (except as stated in this section) patent +license to make, have made, use, offer to sell, sell, import, and otherwise +transfer the Work, where such license applies only to those patent claims +licensable by such Contributor that are necessarily infringed by their Contribution(s) +alone or by combination of their Contribution(s) with the Work to which such +Contribution(s) was submitted. If You institute patent litigation against +any entity (including a cross-claim or counterclaim in a lawsuit) alleging +that the Work or a Contribution incorporated within the Work constitutes direct +or contributory patent infringement, then any patent licenses granted to You +under this License for that Work shall terminate as of the date such litigation +is filed. + +4. Redistribution. You may reproduce and distribute copies of the Work or +Derivative Works thereof in any medium, with or without modifications, and +in Source or Object form, provided that You meet the following conditions: + +(a) You must give any other recipients of the Work or Derivative Works a copy +of this License; and + +(b) You must cause any modified files to carry prominent notices stating that +You changed the files; and + +(c) You must retain, in the Source form of any Derivative Works that You distribute, +all copyright, patent, trademark, and attribution notices from the Source +form of the Work, excluding those notices that do not pertain to any part +of the Derivative Works; and + +(d) If the Work includes a "NOTICE" text file as part of its distribution, +then any Derivative Works that You distribute must include a readable copy +of the attribution notices contained within such NOTICE file, excluding those +notices that do not pertain to any part of the Derivative Works, in at least +one of the following places: within a NOTICE text file distributed as part +of the Derivative Works; within the Source form or documentation, if provided +along with the Derivative Works; or, within a display generated by the Derivative +Works, if and wherever such third-party notices normally appear. The contents +of the NOTICE file are for informational purposes only and do not modify the +License. You may add Your own attribution notices within Derivative Works +that You distribute, alongside or as an addendum to the NOTICE text from the +Work, provided that such additional attribution notices cannot be construed +as modifying the License. + +You may add Your own copyright statement to Your modifications and may provide +additional or different license terms and conditions for use, reproduction, +or distribution of Your modifications, or for any such Derivative Works as +a whole, provided Your use, reproduction, and distribution of the Work otherwise +complies with the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, any +Contribution intentionally submitted for inclusion in the Work by You to the +Licensor shall be under the terms and conditions of this License, without +any additional terms or conditions. Notwithstanding the above, nothing herein +shall supersede or modify the terms of any separate license agreement you +may have executed with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade names, +trademarks, service marks, or product names of the Licensor, except as required +for reasonable and customary use in describing the origin of the Work and +reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or agreed to +in writing, Licensor provides the Work (and each Contributor provides its +Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, either express or implied, including, without limitation, any warranties +or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR +A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness +of using or redistributing the Work and assume any risks associated with Your +exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, whether +in tort (including negligence), contract, or otherwise, unless required by +applicable law (such as deliberate and grossly negligent acts) or agreed to +in writing, shall any Contributor be liable to You for damages, including +any direct, indirect, special, incidental, or consequential damages of any +character arising as a result of this License or out of the use or inability +to use the Work (including but not limited to damages for loss of goodwill, +work stoppage, computer failure or malfunction, or any and all other commercial +damages or losses), even if such Contributor has been advised of the possibility +of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing the Work +or Derivative Works thereof, You may choose to offer, and charge a fee for, +acceptance of support, warranty, indemnity, or other liability obligations +and/or rights consistent with this License. However, in accepting such obligations, +You may act only on Your own behalf and on Your sole responsibility, not on +behalf of any other Contributor, and only if You agree to indemnify, defend, +and hold each Contributor harmless for any liability incurred by, or claims +asserted against, such Contributor by reason of your accepting any such warranty +or additional liability. END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work. + +To apply the Apache License to your work, attach the following boilerplate +notice, with the fields enclosed by brackets "[]" replaced with your own identifying +information. (Don't include the brackets!) The text should be enclosed in +the appropriate comment syntax for the file format. We also recommend that +a file or class name and description of purpose be included on the same "printed +page" as the copyright notice for easier identification within third-party +archives. + +Copyright [yyyy] [name of copyright owner] + +Licensed under the Apache License, Version 2.0 (the "License"); + +you may not use this file except in compliance with the License. + +You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software + +distributed under the License is distributed on an "AS IS" BASIS, + +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + +See the License for the specific language governing permissions and + +limitations under the License. diff --git a/shadps4-arm64-main/externals/openxr-sdk/LICENSES/BSD-3-Clause.txt b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/BSD-3-Clause.txt new file mode 100644 index 0000000..0741db7 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/BSD-3-Clause.txt @@ -0,0 +1,26 @@ +Copyright (c) <year> <owner>. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, +this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, +this list of conditions and the following disclaimer in the documentation +and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its contributors +may be used to endorse or promote products derived from this software without +specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE +USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/shadps4-arm64-main/externals/openxr-sdk/LICENSES/BSL-1.0.txt b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/BSL-1.0.txt new file mode 100644 index 0000000..cff3536 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/BSL-1.0.txt @@ -0,0 +1,23 @@ +Boost Software License - Version 1.0 - August 17th, 2003 + +Permission is hereby granted, free of charge, to any person or organization +obtaining a copy of the software and accompanying documentation covered by +this license (the "Software") to use, reproduce, display, distribute, execute, +and transmit the Software, and to prepare derivative works of the Software, +and to permit third-parties to whom the Software is furnished to do so, all +subject to the following: + +The copyright notices in the Software and this entire statement, including +the above license grant, this restriction and the following disclaimer, must +be included in all copies of the Software, in whole or in part, and all derivative +works of the Software, unless such copies or derivative works are solely in +the form of machine-executable object code generated by a source language +processor. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE +COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES +OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/shadps4-arm64-main/externals/openxr-sdk/LICENSES/CC-BY-4.0.txt b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/CC-BY-4.0.txt new file mode 100644 index 0000000..3f92dfc --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/CC-BY-4.0.txt @@ -0,0 +1,324 @@ +Creative Commons Attribution 4.0 International Creative Commons Corporation +("Creative Commons") is not a law firm and does not provide legal services +or legal advice. Distribution of Creative Commons public licenses does not +create a lawyer-client or other relationship. Creative Commons makes its licenses +and related information available on an "as-is" basis. Creative Commons gives +no warranties regarding its licenses, any material licensed under their terms +and conditions, or any related information. Creative Commons disclaims all +liability for damages resulting from their use to the fullest extent possible. + +Using Creative Commons Public Licenses + +Creative Commons public licenses provide a standard set of terms and conditions +that creators and other rights holders may use to share original works of +authorship and other material subject to copyright and certain other rights +specified in the public license below. The following considerations are for +informational purposes only, are not exhaustive, and do not form part of our +licenses. + +Considerations for licensors: Our public licenses are intended for use by +those authorized to give the public permission to use material in ways otherwise +restricted by copyright and certain other rights. Our licenses are irrevocable. +Licensors should read and understand the terms and conditions of the license +they choose before applying it. Licensors should also secure all rights necessary +before applying our licenses so that the public can reuse the material as +expected. Licensors should clearly mark any material not subject to the license. +This includes other CC-licensed material, or material used under an exception +or limitation to copyright. More considerations for licensors : wiki.creativecommons.org/Considerations_for_licensors + +Considerations for the public: By using one of our public licenses, a licensor +grants the public permission to use the licensed material under specified +terms and conditions. If the licensor's permission is not necessary for any +reason–for example, because of any applicable exception or limitation to copyright–then +that use is not regulated by the license. Our licenses grant only permissions +under copyright and certain other rights that a licensor has authority to +grant. Use of the licensed material may still be restricted for other reasons, +including because others have copyright or other rights in the material. A +licensor may make special requests, such as asking that all changes be marked +or described. Although not required by our licenses, you are encouraged to +respect those requests where reasonable. More considerations for the public +: wiki.creativecommons.org/Considerations_for_licensees Creative Commons Attribution +4.0 International Public License + +By exercising the Licensed Rights (defined below), You accept and agree to +be bound by the terms and conditions of this Creative Commons Attribution +4.0 International Public License ("Public License"). To the extent this Public +License may be interpreted as a contract, You are granted the Licensed Rights +in consideration of Your acceptance of these terms and conditions, and the +Licensor grants You such rights in consideration of benefits the Licensor +receives from making the Licensed Material available under these terms and +conditions. + +Section 1 – Definitions. + +a. Adapted Material means material subject to Copyright and Similar Rights +that is derived from or based upon the Licensed Material and in which the +Licensed Material is translated, altered, arranged, transformed, or otherwise +modified in a manner requiring permission under the Copyright and Similar +Rights held by the Licensor. For purposes of this Public License, where the +Licensed Material is a musical work, performance, or sound recording, Adapted +Material is always produced where the Licensed Material is synched in timed +relation with a moving image. + +b. Adapter's License means the license You apply to Your Copyright and Similar +Rights in Your contributions to Adapted Material in accordance with the terms +and conditions of this Public License. + +c. Copyright and Similar Rights means copyright and/or similar rights closely +related to copyright including, without limitation, performance, broadcast, +sound recording, and Sui Generis Database Rights, without regard to how the +rights are labeled or categorized. For purposes of this Public License, the +rights specified in Section 2(b)(1)-(2) are not Copyright and Similar Rights. + +d. Effective Technological Measures means those measures that, in the absence +of proper authority, may not be circumvented under laws fulfilling obligations +under Article 11 of the WIPO Copyright Treaty adopted on December 20, 1996, +and/or similar international agreements. + +e. Exceptions and Limitations means fair use, fair dealing, and/or any other +exception or limitation to Copyright and Similar Rights that applies to Your +use of the Licensed Material. + +f. Licensed Material means the artistic or literary work, database, or other +material to which the Licensor applied this Public License. + +g. Licensed Rights means the rights granted to You subject to the terms and +conditions of this Public License, which are limited to all Copyright and +Similar Rights that apply to Your use of the Licensed Material and that the +Licensor has authority to license. + +h. Licensor means the individual(s) or entity(ies) granting rights under this +Public License. + +i. Share means to provide material to the public by any means or process that +requires permission under the Licensed Rights, such as reproduction, public +display, public performance, distribution, dissemination, communication, or +importation, and to make material available to the public including in ways +that members of the public may access the material from a place and at a time +individually chosen by them. + +j. Sui Generis Database Rights means rights other than copyright resulting +from Directive 96/9/EC of the European Parliament and of the Council of 11 +March 1996 on the legal protection of databases, as amended and/or succeeded, +as well as other essentially equivalent rights anywhere in the world. + +k. You means the individual or entity exercising the Licensed Rights under +this Public License. Your has a corresponding meaning. + +Section 2 – Scope. + + a. License grant. + +1. Subject to the terms and conditions of this Public License, the Licensor +hereby grants You a worldwide, royalty-free, non-sublicensable, non-exclusive, +irrevocable license to exercise the Licensed Rights in the Licensed Material +to: + + A. reproduce and Share the Licensed Material, in whole or in part; and + + B. produce, reproduce, and Share Adapted Material. + +2. Exceptions and Limitations. For the avoidance of doubt, where Exceptions +and Limitations apply to Your use, this Public License does not apply, and +You do not need to comply with its terms and conditions. + + 3. Term. The term of this Public License is specified in Section 6(a). + +4. Media and formats; technical modifications allowed. The Licensor authorizes +You to exercise the Licensed Rights in all media and formats whether now known +or hereafter created, and to make technical modifications necessary to do +so. The Licensor waives and/or agrees not to assert any right or authority +to forbid You from making technical modifications necessary to exercise the +Licensed Rights, including technical modifications necessary to circumvent +Effective Technological Measures. For purposes of this Public License, simply +making modifications authorized by this Section 2(a)(4) never produces Adapted +Material. + + 5. Downstream recipients. + +A. Offer from the Licensor – Licensed Material. Every recipient of the Licensed +Material automatically receives an offer from the Licensor to exercise the +Licensed Rights under the terms and conditions of this Public License. + +B. No downstream restrictions. You may not offer or impose any additional +or different terms or conditions on, or apply any Effective Technological +Measures to, the Licensed Material if doing so restricts exercise of the Licensed +Rights by any recipient of the Licensed Material. + +6. No endorsement. Nothing in this Public License constitutes or may be construed +as permission to assert or imply that You are, or that Your use of the Licensed +Material is, connected with, or sponsored, endorsed, or granted official status +by, the Licensor or others designated to receive attribution as provided in +Section 3(a)(1)(A)(i). + + b. Other rights. + +1. Moral rights, such as the right of integrity, are not licensed under this +Public License, nor are publicity, privacy, and/or other similar personality +rights; however, to the extent possible, the Licensor waives and/or agrees +not to assert any such rights held by the Licensor to the limited extent necessary +to allow You to exercise the Licensed Rights, but not otherwise. + +2. Patent and trademark rights are not licensed under this Public License. + +3. To the extent possible, the Licensor waives any right to collect royalties +from You for the exercise of the Licensed Rights, whether directly or through +a collecting society under any voluntary or waivable statutory or compulsory +licensing scheme. In all other cases the Licensor expressly reserves any right +to collect such royalties. + +Section 3 – License Conditions. + +Your exercise of the Licensed Rights is expressly made subject to the following +conditions. + + a. Attribution. + +1. If You Share the Licensed Material (including in modified form), You must: + +A. retain the following if it is supplied by the Licensor with the Licensed +Material: + +i. identification of the creator(s) of the Licensed Material and any others +designated to receive attribution, in any reasonable manner requested by the +Licensor (including by pseudonym if designated); + + ii. a copyright notice; + + iii. a notice that refers to this Public License; + + iv. a notice that refers to the disclaimer of warranties; + +v. a URI or hyperlink to the Licensed Material to the extent reasonably practicable; + +B. indicate if You modified the Licensed Material and retain an indication +of any previous modifications; and + +C. indicate the Licensed Material is licensed under this Public License, and +include the text of, or the URI or hyperlink to, this Public License. + +2. You may satisfy the conditions in Section 3(a)(1) in any reasonable manner +based on the medium, means, and context in which You Share the Licensed Material. +For example, it may be reasonable to satisfy the conditions by providing a +URI or hyperlink to a resource that includes the required information. + +3. If requested by the Licensor, You must remove any of the information required +by Section 3(a)(1)(A) to the extent reasonably practicable. + +4. If You Share Adapted Material You produce, the Adapter's License You apply +must not prevent recipients of the Adapted Material from complying with this +Public License. + +Section 4 – Sui Generis Database Rights. + +Where the Licensed Rights include Sui Generis Database Rights that apply to +Your use of the Licensed Material: + +a. for the avoidance of doubt, Section 2(a)(1) grants You the right to extract, +reuse, reproduce, and Share all or a substantial portion of the contents of +the database; + +b. if You include all or a substantial portion of the database contents in +a database in which You have Sui Generis Database Rights, then the database +in which You have Sui Generis Database Rights (but not its individual contents) +is Adapted Material; and + +c. You must comply with the conditions in Section 3(a) if You Share all or +a substantial portion of the contents of the database. + +For the avoidance of doubt, this Section 4 supplements and does not replace +Your obligations under this Public License where the Licensed Rights include +other Copyright and Similar Rights. + +Section 5 – Disclaimer of Warranties and Limitation of Liability. + +a. Unless otherwise separately undertaken by the Licensor, to the extent possible, +the Licensor offers the Licensed Material as-is and as-available, and makes +no representations or warranties of any kind concerning the Licensed Material, +whether express, implied, statutory, or other. This includes, without limitation, +warranties of title, merchantability, fitness for a particular purpose, non-infringement, +absence of latent or other defects, accuracy, or the presence or absence of +errors, whether or not known or discoverable. Where disclaimers of warranties +are not allowed in full or in part, this disclaimer may not apply to You. + +b. To the extent possible, in no event will the Licensor be liable to You +on any legal theory (including, without limitation, negligence) or otherwise +for any direct, special, indirect, incidental, consequential, punitive, exemplary, +or other losses, costs, expenses, or damages arising out of this Public License +or use of the Licensed Material, even if the Licensor has been advised of +the possibility of such losses, costs, expenses, or damages. Where a limitation +of liability is not allowed in full or in part, this limitation may not apply +to You. + +c. The disclaimer of warranties and limitation of liability provided above +shall be interpreted in a manner that, to the extent possible, most closely +approximates an absolute disclaimer and waiver of all liability. + +Section 6 – Term and Termination. + +a. This Public License applies for the term of the Copyright and Similar Rights +licensed here. However, if You fail to comply with this Public License, then +Your rights under this Public License terminate automatically. + +b. Where Your right to use the Licensed Material has terminated under Section +6(a), it reinstates: + +1. automatically as of the date the violation is cured, provided it is cured +within 30 days of Your discovery of the violation; or + + 2. upon express reinstatement by the Licensor. + +c. For the avoidance of doubt, this Section 6(b) does not affect any right +the Licensor may have to seek remedies for Your violations of this Public +License. + +d. For the avoidance of doubt, the Licensor may also offer the Licensed Material +under separate terms or conditions or stop distributing the Licensed Material +at any time; however, doing so will not terminate this Public License. + + e. Sections 1, 5, 6, 7, and 8 survive termination of this Public License. + +Section 7 – Other Terms and Conditions. + +a. The Licensor shall not be bound by any additional or different terms or +conditions communicated by You unless expressly agreed. + +b. Any arrangements, understandings, or agreements regarding the Licensed +Material not stated herein are separate from and independent of the terms +and conditions of this Public License. + +Section 8 – Interpretation. + +a. For the avoidance of doubt, this Public License does not, and shall not +be interpreted to, reduce, limit, restrict, or impose conditions on any use +of the Licensed Material that could lawfully be made without permission under +this Public License. + +b. To the extent possible, if any provision of this Public License is deemed +unenforceable, it shall be automatically reformed to the minimum extent necessary +to make it enforceable. If the provision cannot be reformed, it shall be severed +from this Public License without affecting the enforceability of the remaining +terms and conditions. + +c. No term or condition of this Public License will be waived and no failure +to comply consented to unless expressly agreed to by the Licensor. + +d. Nothing in this Public License constitutes or may be interpreted as a limitation +upon, or waiver of, any privileges and immunities that apply to the Licensor +or You, including from the legal processes of any jurisdiction or authority. + +Creative Commons is not a party to its public licenses. Notwithstanding, Creative +Commons may elect to apply one of its public licenses to material it publishes +and in those instances will be considered the "Licensor." The text of the +Creative Commons public licenses is dedicated to the public domain under the +CC0 Public Domain Dedication. Except for the limited purpose of indicating +that material is shared under a Creative Commons public license or as otherwise +permitted by the Creative Commons policies published at creativecommons.org/policies, +Creative Commons does not authorize the use of the trademark "Creative Commons" +or any other trademark or logo of Creative Commons without its prior written +consent including, without limitation, in connection with any unauthorized +modifications to any of its public licenses or any other arrangements, understandings, +or agreements concerning use of licensed material. For the avoidance of doubt, +this paragraph does not form part of the public licenses. + +Creative Commons may be contacted at creativecommons.org. diff --git a/shadps4-arm64-main/externals/openxr-sdk/LICENSES/CC0-1.0.txt b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/CC0-1.0.txt new file mode 100644 index 0000000..a343ccd --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/CC0-1.0.txt @@ -0,0 +1,119 @@ +Creative Commons Legal Code + +CC0 1.0 Universal CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES +NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE +AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION +ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE USE +OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED HEREUNDER, AND DISCLAIMS +LIABILITY FOR DAMAGES RESULTING FROM THE USE OF THIS DOCUMENT OR THE INFORMATION +OR WORKS PROVIDED HEREUNDER. + +Statement of Purpose + +The laws of most jurisdictions throughout the world automatically confer exclusive +Copyright and Related Rights (defined below) upon the creator and subsequent +owner(s) (each and all, an "owner") of an original work of authorship and/or +a database (each, a "Work"). + +Certain owners wish to permanently relinquish those rights to a Work for the +purpose of contributing to a commons of creative, cultural and scientific +works ("Commons") that the public can reliably and without fear of later claims +of infringement build upon, modify, incorporate in other works, reuse and +redistribute as freely as possible in any form whatsoever and for any purposes, +including without limitation commercial purposes. These owners may contribute +to the Commons to promote the ideal of a free culture and the further production +of creative, cultural and scientific works, or to gain reputation or greater +distribution for their Work in part through the use and efforts of others. + +For these and/or other purposes and motivations, and without any expectation +of additional consideration or compensation, the person associating CC0 with +a Work (the "Affirmer"), to the extent that he or she is an owner of Copyright +and Related Rights in the Work, voluntarily elects to apply CC0 to the Work +and publicly distribute the Work under its terms, with knowledge of his or +her Copyright and Related Rights in the Work and the meaning and intended +legal effect of CC0 on those rights. + +1. Copyright and Related Rights. A Work made available under CC0 may be protected +by copyright and related or neighboring rights ("Copyright and Related Rights"). +Copyright and Related Rights include, but are not limited to, the following: + +i. the right to reproduce, adapt, distribute, perform, display, communicate, +and translate a Work; + + ii. moral rights retained by the original author(s) and/or performer(s); + +iii. publicity and privacy rights pertaining to a person's image or likeness +depicted in a Work; + +iv. rights protecting against unfair competition in regards to a Work, subject +to the limitations in paragraph 4(a), below; + +v. rights protecting the extraction, dissemination, use and reuse of data +in a Work; + +vi. database rights (such as those arising under Directive 96/9/EC of the +European Parliament and of the Council of 11 March 1996 on the legal protection +of databases, and under any national implementation thereof, including any +amended or successor version of such directive); and + +vii. other similar, equivalent or corresponding rights throughout the world +based on applicable law or treaty, and any national implementations thereof. + +2. Waiver. To the greatest extent permitted by, but not in contravention of, +applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and +unconditionally waives, abandons, and surrenders all of Affirmer's Copyright +and Related Rights and associated claims and causes of action, whether now +known or unknown (including existing as well as future claims and causes of +action), in the Work (i) in all territories worldwide, (ii) for the maximum +duration provided by applicable law or treaty (including future time extensions), +(iii) in any current or future medium and for any number of copies, and (iv) +for any purpose whatsoever, including without limitation commercial, advertising +or promotional purposes (the "Waiver"). Affirmer makes the Waiver for the +benefit of each member of the public at large and to the detriment of Affirmer's +heirs and successors, fully intending that such Waiver shall not be subject +to revocation, rescission, cancellation, termination, or any other legal or +equitable action to disrupt the quiet enjoyment of the Work by the public +as contemplated by Affirmer's express Statement of Purpose. + +3. Public License Fallback. Should any part of the Waiver for any reason be +judged legally invalid or ineffective under applicable law, then the Waiver +shall be preserved to the maximum extent permitted taking into account Affirmer's +express Statement of Purpose. In addition, to the extent the Waiver is so +judged Affirmer hereby grants to each affected person a royalty-free, non +transferable, non sublicensable, non exclusive, irrevocable and unconditional +license to exercise Affirmer's Copyright and Related Rights in the Work (i) +in all territories worldwide, (ii) for the maximum duration provided by applicable +law or treaty (including future time extensions), (iii) in any current or +future medium and for any number of copies, and (iv) for any purpose whatsoever, +including without limitation commercial, advertising or promotional purposes +(the "License"). The License shall be deemed effective as of the date CC0 +was applied by Affirmer to the Work. Should any part of the License for any +reason be judged legally invalid or ineffective under applicable law, such +partial invalidity or ineffectiveness shall not invalidate the remainder of +the License, and in such case Affirmer hereby affirms that he or she will +not (i) exercise any of his or her remaining Copyright and Related Rights +in the Work or (ii) assert any associated claims and causes of action with +respect to the Work, in either case contrary to Affirmer's express Statement +of Purpose. + + 4. Limitations and Disclaimers. + +a. No trademark or patent rights held by Affirmer are waived, abandoned, surrendered, +licensed or otherwise affected by this document. + +b. Affirmer offers the Work as-is and makes no representations or warranties +of any kind concerning the Work, express, implied, statutory or otherwise, +including without limitation warranties of title, merchantability, fitness +for a particular purpose, non infringement, or the absence of latent or other +defects, accuracy, or the present or absence of errors, whether or not discoverable, +all to the greatest extent permissible under applicable law. + +c. Affirmer disclaims responsibility for clearing rights of other persons +that may apply to the Work or any use thereof, including without limitation +any person's Copyright and Related Rights in the Work. Further, Affirmer disclaims +responsibility for obtaining any necessary consents, permissions or other +rights required for any use of the Work. + +d. Affirmer understands and acknowledges that Creative Commons is not a party +to this document and has no duty or obligation with respect to this CC0 or +use of the Work. diff --git a/shadps4-arm64-main/externals/openxr-sdk/LICENSES/ISC.txt b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/ISC.txt new file mode 100644 index 0000000..b9c199c --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/ISC.txt @@ -0,0 +1,8 @@ +ISC License: + +Copyright (c) 2004-2010 by Internet Systems Consortium, Inc. ("ISC") +Copyright (c) 1995-2003 by Internet Software Consortium + +Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. diff --git a/shadps4-arm64-main/externals/openxr-sdk/LICENSES/LicenseRef-Khronos-Free-Use-License-for-Software-and-Documentation.txt b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/LicenseRef-Khronos-Free-Use-License-for-Software-and-Documentation.txt new file mode 100644 index 0000000..31ca8fe --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/LicenseRef-Khronos-Free-Use-License-for-Software-and-Documentation.txt @@ -0,0 +1,18 @@ +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and/or associated documentation files (the +"Materials"), to deal in the Materials without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Materials, and to +permit persons to whom the Materials are furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Materials. + +THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. diff --git a/shadps4-arm64-main/externals/openxr-sdk/LICENSES/LicenseRef-KhronosSpecCopyright-WithNormativeWording-v10.txt b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/LicenseRef-KhronosSpecCopyright-WithNormativeWording-v10.txt new file mode 100644 index 0000000..b78b019 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/LicenseRef-KhronosSpecCopyright-WithNormativeWording-v10.txt @@ -0,0 +1,53 @@ +Copyright (c) 2017-2026 The Khronos Group Inc. + +This Specification is protected by copyright laws and contains material +proprietary to Khronos. +Except as described by these terms, it or any components may not be +reproduced, republished, distributed, transmitted, displayed, broadcast or +otherwise exploited in any manner without the express prior written +permission of Khronos. + +Khronos grants a conditional copyright license to use and reproduce the +unmodified Specification for any purpose, without fee or royalty, EXCEPT no +licenses to any patent, trademark or other intellectual property rights are +granted under these terms. + +Khronos makes no, and expressly disclaims any, representations or +warranties, express or implied, regarding this Specification, including, +without limitation: merchantability, fitness for a particular purpose, +non-infringement of any intellectual property, correctness, accuracy, +completeness, timeliness, and reliability. +Under no circumstances will Khronos, or any of its Promoters, Contributors +or Members, or their respective partners, officers, directors, employees, +agents or representatives be liable for any damages, whether direct, +indirect, special or consequential damages for lost revenues, lost profits, +or otherwise, arising from or in connection with these materials. + +The Khronos Intellectual Property Rights Policy defines the terms 'Scope', +'Compliant Portion', and 'Necessary Patent Claims'. + +Some parts of this Specification are purely informative and so are EXCLUDED +from the Scope of this Specification. +The <<introduction-document-conventions,Document Conventions>> section of +the <<introduction>> defines how these parts of the Specification are +identified. + +Where this Specification uses technical terminology, defined in the +<<glossary, Glossary>> or otherwise, that refer to enabling technologies +that are not expressly set forth in this Specification, those enabling +technologies are EXCLUDED from the Scope of this Specification. +For clarity, enabling technologies not disclosed with particularity in this +Specification (e.g. semiconductor manufacturing technology, hardware +architecture, processor architecture or microarchitecture, memory +architecture, compiler technology, object oriented technology, basic +operating system technology, compression technology, algorithms, and so on) +are NOT to be considered expressly set forth; only those application program +interfaces and data structures disclosed with particularity are included in +the Scope of this Specification. + +For purposes of the Khronos Intellectual Property Rights Policy as it +relates to the definition of Necessary Patent Claims, all recommended or +optional features, behaviors and functionality set forth in this +Specification, if implemented, are considered to be included as Compliant +Portions. + diff --git a/shadps4-arm64-main/externals/openxr-sdk/LICENSES/LicenseRef-jsoncpp-public-domain.txt b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/LicenseRef-jsoncpp-public-domain.txt new file mode 100644 index 0000000..0168178 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/LicenseRef-jsoncpp-public-domain.txt @@ -0,0 +1,16 @@ +The JsonCpp library's source code, including accompanying documentation, +tests and demonstration applications, are licensed under the following +conditions... + +The author (Baptiste Lepilleur) explicitly disclaims copyright in all +jurisdictions which recognize such a disclaimer. In such jurisdictions, +this software is released into the Public Domain. + +In jurisdictions which do not recognize Public Domain property (e.g. Germany as of +2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur, and is +released under the terms of the MIT License (see below). + +In jurisdictions which recognize Public Domain property, the user of this +software may choose to accept it either as 1) Public Domain, 2) under the +conditions of the MIT License (see below), or 3) under the terms of dual +Public Domain/MIT License conditions described here, as they choose. diff --git a/shadps4-arm64-main/externals/openxr-sdk/LICENSES/MIT.txt b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/MIT.txt new file mode 100644 index 0000000..204b93d --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/MIT.txt @@ -0,0 +1,19 @@ +MIT License Copyright (c) <year> <copyright holders> + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is furnished +to do so, subject to the following conditions: + +The above copyright notice and this permission notice (including the next +paragraph) shall be included in all copies or substantial portions of the +Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS +OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF +OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/shadps4-arm64-main/externals/openxr-sdk/LICENSES/OFL-1.1-RFN.txt b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/OFL-1.1-RFN.txt new file mode 100644 index 0000000..084c962 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/OFL-1.1-RFN.txt @@ -0,0 +1,90 @@ +Copyright (c) <dates>, <Copyright Holder> (<URL|email>), + +with Reserved Font Name <Reserved Font Name>. This Font Software is licensed +under the SIL Open Font License, Version 1.1. + +This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL +SIL OPEN FONT LICENSE + +Version 1.1 - 26 February 2007 + +PREAMBLE + +The goals of the Open Font License (OFL) are to stimulate worldwide development +of collaborative font projects, to support the font creation efforts of academic +and linguistic communities, and to provide a free and open framework in which +fonts may be shared and improved in partnership with others. + +The OFL allows the licensed fonts to be used, studied, modified and redistributed +freely as long as they are not sold by themselves. The fonts, including any +derivative works, can be bundled, embedded, redistributed and/or sold with +any software provided that any reserved names are not used by derivative works. +The fonts and derivatives, however, cannot be released under any other type +of license. The requirement for fonts to remain under this license does not +apply to any document created using the fonts or their derivatives. + +DEFINITIONS + +"Font Software" refers to the set of files released by the Copyright Holder(s) +under this license and clearly marked as such. This may include source files, +build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the copyright +statement(s). + +"Original Version" refers to the collection of Font Software components as +distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, deleting, or +substituting — in part or in whole — any of the components of the Original +Version, by changing formats or by porting the Font Software to a new environment. + +"Author" refers to any designer, engineer, programmer, technical writer or +other person who contributed to the Font Software. + +PERMISSION & CONDITIONS + +Permission is hereby granted, free of charge, to any person obtaining a copy +of the Font Software, to use, study, copy, merge, embed, modify, redistribute, +and sell modified and unmodified copies of the Font Software, subject to the +following conditions: + +1) Neither the Font Software nor any of its individual components, in Original +or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, redistributed +and/or sold with any software, provided that each copy contains the above +copyright notice and this license. These can be included either as stand-alone +text files, human-readable headers or in the appropriate machine-readable +metadata fields within text or binary files as long as those fields can be +easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font Name(s) +unless explicit written permission is granted by the corresponding Copyright +Holder. This restriction only applies to the primary font name as presented +to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font Software +shall not be used to promote, endorse or advertise any Modified Version, except +to acknowledge the contribution(s) of the Copyright Holder(s) and the Author(s) +or with their explicit written permission. + +5) The Font Software, modified or unmodified, in part or in whole, must be +distributed entirely under this license, and must not be distributed under +any other license. The requirement for fonts to remain under this license +does not apply to any document created using the Font Software. + +TERMINATION + +This license becomes null and void if any of the above conditions are not met. + +DISCLAIMER + +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, +TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE +FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, +INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT +SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE. diff --git a/shadps4-arm64-main/externals/openxr-sdk/LICENSES/Unlicense.txt b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/Unlicense.txt new file mode 100644 index 0000000..24a8f90 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/Unlicense.txt @@ -0,0 +1,20 @@ +This is free and unencumbered software released into the public domain. + +Anyone is free to copy, modify, publish, use, compile, sell, or distribute +this software, either in source code form or as a compiled binary, for any +purpose, commercial or non-commercial, and by any means. + +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and +to the detriment of our heirs and successors. We intend this dedication to +be an overt act of relinquishment in perpetuity of all present and future +rights to this software under copyright law. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS +BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH +THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. For more information, +please refer to <https://unlicense.org/> diff --git a/shadps4-arm64-main/externals/openxr-sdk/LICENSES/WTFPL.txt b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/WTFPL.txt new file mode 100644 index 0000000..7a3094a --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/WTFPL.txt @@ -0,0 +1,11 @@ +DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE +Version 2, December 2004 + +Copyright (C) 2004 Sam Hocevar <sam@hocevar.net> + +Everyone is permitted to copy and distribute verbatim or modified copies of this license document, and changing it is allowed as long as the name is changed. + +DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE +TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. You just DO WHAT THE FUCK YOU WANT TO. diff --git a/shadps4-arm64-main/externals/openxr-sdk/LICENSES/Zlib.txt b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/Zlib.txt new file mode 100644 index 0000000..e0e3605 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/LICENSES/Zlib.txt @@ -0,0 +1,11 @@ +zlib License + +This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. + +Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + + 3. This notice may not be removed or altered from any source distribution. diff --git a/shadps4-arm64-main/externals/openxr-sdk/README.md b/shadps4-arm64-main/externals/openxr-sdk/README.md new file mode 100644 index 0000000..7038316 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/README.md @@ -0,0 +1,143 @@ +# OpenXR™ Software Development Kit (SDK) Project + +<!-- +Copyright (c) 2017-2026 The Khronos Group Inc. + +SPDX-License-Identifier: CC-BY-4.0 +--> + +This repository contains OpenXR headers, as well as source code and build scripts +for the OpenXR loader. +It contains all generated source files and headers pre-generated for minimum dependencies. + +The authoritative public repository for this project is located at +<https://github.com/KhronosGroup/OpenXR-SDK>. + +The public repository containing the scripts that generate the files in this repository +is located at +<https://github.com/KhronosGroup/OpenXR-SDK-Source>. +It hosts the public Issue tracker, and accepts patches (Pull Requests) from the +general public. +That repository is also where sample code (hello_xr) and API layer source can be found. + +**Note that this repo is effectively read-only: changes to this repo should be made in the [OpenXR-SDK-Source](https://github.com/KhronosGroup/OpenXR-SDK-Source) repo instead** + +## Directory Structure + +<!-- REUSE-IgnoreStart --> +- `BUILDING.md` - Instructions for building the projects +- `README.md` - This file +- `COPYING.md` - Copyright and licensing information +- `CODE_OF_CONDUCT.md` - Code of Conduct +- `external/` - External code for projects in the repo +- `include/` - OpenXR header files +- `src/external/jsoncpp` - The jsoncpp project source code, an included dependency of the loader. +- `src/loader` - OpenXR loader code, **including generated code** +<!-- REUSE-IgnoreEnd --> + +## Building + +The project is set up to build using CMake. + +### (Optional) Building the OpenXR Loader as a DLL + +By default, the OpenXR loader is built as a static library on Windows and a dynamic library on other platforms. +To specify alternate behavior, define the CMake option `DYNAMIC_LOADER`, +e.g. by adding `-DDYNAMIC_LOADER=ON` or `-DDYNAMIC_LOADER=OFF` to your CMake command line. + +### Windows + +Building the OpenXR components in this tree on Windows is supported using +Visual Studio 2013 and newer. Before beginning, make sure the appropriate +"msbuild.exe" is in your PATH. Also, when generating the solutions/projects +using CMake, be sure to use the correct compiler version number. The +following table is provided to help you: + +| Visual Studio | Version Number | +| -------------------- |:--------------:| +| Visual Studio 2017 | 15 | +| Visual Studio 2019 | 16 | +| Visual Studio 2022 | 17 | + +Specific sample command lines for building follow. +If you're already familiar with the process of building a project with +CMake, you may skim or skip these instructions. + +#### Windows 64-bit + +First, generate the 64-bit solution and project files using CMake: + +```cmd +mkdir build\win64 +cd build\win64 +cmake -G "Visual Studio [Version Number] Win64" ..\.. +``` + +Finally, open the `build\win64\OPENXR.sln` in the Visual Studio to build the loader. + +#### Windows 32-bit + +First, generate the 32-bit solution and project files using CMake: + +```cmd +mkdir build\win32 +cd build\win32 +cmake -G "Visual Studio [Version Number]" ..\.. +``` + +Open the `build\win32\OPENXR.sln` in the Visual Studio to build the loader. + +### Linux + +The following set of Debian/Ubuntu packages provides all required libs for building for xlib or xcb with OpenGL and Vulkan support. + +- `build-essential` +- `cmake` (of _somewhat_ recent vintage, 3.10+ known working) +- `libgl1-mesa-dev` +- `libvulkan-dev` +- `libx11-xcb-dev` +- `libxcb-dri2-0-dev` +- `libxcb-glx0-dev` +- `libxcb-icccm4-dev` +- `libxcb-keysyms1-dev` +- `libxcb-randr0-dev` +- `libxrandr-dev` +- `libxxf86vm-dev` +- `mesa-common-dev` + +Specific sample command lines for building follow. +If you're already familiar with the process of building a project with +CMake, you may skim or skip these instructions. + +#### Linux Debug + +```sh +mkdir -p build/linux_debug +cd build/linux_debug +cmake -DCMAKE_BUILD_TYPE=Debug ../.. +make +``` + +#### Linux Release + +```sh +mkdir -p build/linux_release +cd build/linux_release +cmake -DCMAKE_BUILD_TYPE=Release ../.. +make +``` + +### macOS + +Building the OpenXR components in this tree on macOS is supported using Xcode +14.0 and newer. You may need to install Xcode Command Line Tools and cmake. + +First, generate the Xcode project file using CMake: + +```cmd +mkdir -p build/macos +cd build/macos +cmake -G "Xcode" ../.. +``` + +Finally, open the build/macos/OPENXR.xcodeproj in Xcode to build the samples. diff --git a/shadps4-arm64-main/externals/openxr-sdk/include/CMakeLists.txt b/shadps4-arm64-main/externals/openxr-sdk/include/CMakeLists.txt new file mode 100644 index 0000000..9572a66 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/include/CMakeLists.txt @@ -0,0 +1,17 @@ +# Copyright (c) 2017-2026 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +add_subdirectory(openxr) diff --git a/shadps4-arm64-main/externals/openxr-sdk/include/generated_header_list.txt b/shadps4-arm64-main/externals/openxr-sdk/include/generated_header_list.txt new file mode 100644 index 0000000..6ed8e33 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/include/generated_header_list.txt @@ -0,0 +1,6 @@ +openxr.h +openxr_loader_negotiation.h +openxr_platform.h +openxr_reflection.h +openxr_reflection_structs.h +openxr_reflection_parent_structs.h diff --git a/shadps4-arm64-main/externals/openxr-sdk/include/generated_header_list.txt.license b/shadps4-arm64-main/externals/openxr-sdk/include/generated_header_list.txt.license new file mode 100644 index 0000000..3509600 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/include/generated_header_list.txt.license @@ -0,0 +1,5 @@ +Copyright (c) 2017-2026 The Khronos Group Inc. + +SPDX-License-Identifier: Apache-2.0 + +License is being kept in a separate file here because the txt file is parsed by multiple scripts. diff --git a/shadps4-arm64-main/externals/openxr-sdk/include/openxr/CMakeLists.txt b/shadps4-arm64-main/externals/openxr-sdk/include/openxr/CMakeLists.txt new file mode 100644 index 0000000..9541f2f --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/include/openxr/CMakeLists.txt @@ -0,0 +1,134 @@ +# Copyright (c) 2017-2026 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# Generate OpenXR header files. +# Get the list of generated headers from the common single-point-of-truth +file(STRINGS "../generated_header_list.txt" HEADERS LENGTH_MINIMUM 8) + +set(HAVE_PREGENERATED TRUE) +set(SOURCE_HEADERS) +foreach(output ${HEADERS}) + list(APPEND SOURCE_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/${output}") + if(NOT EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${output}") + set(HAVE_PREGENERATED FALSE) + endif() +endforeach() + +add_library(headers INTERFACE) +# Create alias so that it can be used the same whether vendored as source or found with CMake. +# Other targets that need the OpenXR headers should specify OpenXR::headers in their target_link_libraries. +add_library(OpenXR::headers ALIAS headers) +target_include_directories( + headers INTERFACE $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}> +) + +if(HAVE_PREGENERATED AND NOT BUILD_FORCE_GENERATION) + add_custom_target( + generate_openxr_header + COMMENT "Using found pre-generated OpenXR headers." + ) + + set(INSTALL_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/openxr_platform_defines.h" + ${SOURCE_HEADERS} + ) + + # All headers are in the source dir + target_include_directories( + headers INTERFACE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include> + ) +else() + + set(GENERATED_HEADERS) + set(OUTPUT_STAMPS) + # Copy the openxr_platform_defines.h file and place it in the binary (build) directory. + configure_file( + openxr_platform_defines.h + "${CMAKE_CURRENT_BINARY_DIR}/openxr_platform_defines.h" COPYONLY + ) + + # Generate the header files and place it in the binary (build) directory. + file( + GLOB _templates + LIST_DIRECTORIES false + CONFIGURE_DEPENDS + "${PROJECT_SOURCE_DIR}/specification/scripts/template_*" + ) + foreach(output ${HEADERS}) + if("${output}" MATCHES "reflection") + set(_extra_deps + "${PROJECT_SOURCE_DIR}/specification/scripts/jinja_helpers.py" + ${_templates} + ) + else() + unset(_extra_deps) + endif() + add_custom_command( + OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${output}" + COMMAND + "${CMAKE_COMMAND}" -E env "PYTHONPATH=${CODEGEN_PYTHON_PATH}" + "${Python3_EXECUTABLE}" + "${PROJECT_SOURCE_DIR}/specification/scripts/genxr.py" -registry + "${PROJECT_SOURCE_DIR}/specification/registry/xr.xml" -o + "${CMAKE_CURRENT_BINARY_DIR}" ${output} + DEPENDS + "${PROJECT_SOURCE_DIR}/specification/scripts/genxr.py" + "${PROJECT_SOURCE_DIR}/specification/scripts/cgenerator.py" + "${PROJECT_SOURCE_DIR}/specification/scripts/creflectiongenerator.py" + "${PROJECT_SOURCE_DIR}/specification/scripts/generator.py" + "${PROJECT_SOURCE_DIR}/specification/scripts/reg.py" + "${PROJECT_SOURCE_DIR}/specification/registry/xr.xml" + ${_extra_deps} + COMMENT "Generating ${CMAKE_CURRENT_BINARY_DIR}/${output}" + VERBATIM + ) + list(APPEND GENERATED_HEADERS "${CMAKE_CURRENT_BINARY_DIR}/${output}") + endforeach() + + # cmake-format: off + set_source_files_properties(${GENERATED_HEADERS} + PROPERTIES + GENERATED TRUE + SKIP_LINTING ON + ) + # cmake-format: on + + set(INSTALL_HEADERS ${CMAKE_CURRENT_BINARY_DIR}/openxr_platform_defines.h + ${GENERATED_HEADERS} + ) + + # Define generate_openxr_header target to generate the OpenXR header files. + # Not used directly - depended on by OpenXR::headers + add_custom_target( + generate_openxr_header + SOURCES "${PROJECT_SOURCE_DIR}/specification/registry/xr.xml" + DEPENDS ${GENERATED_HEADERS} ${OUTPUT_STAMPS} + ) + # Headers are all in the binary dir + target_include_directories( + headers INTERFACE $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include> + ) +endif() +set_target_properties( + generate_openxr_header PROPERTIES FOLDER ${CODEGEN_FOLDER} +) + +add_dependencies(headers generate_openxr_header) + +install( + FILES ${INSTALL_HEADERS} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/openxr + COMPONENT Headers +) diff --git a/shadps4-arm64-main/externals/openxr-sdk/include/openxr/openxr.h b/shadps4-arm64-main/externals/openxr-sdk/include/openxr/openxr.h new file mode 100644 index 0000000..af56c0f --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/include/openxr/openxr.h @@ -0,0 +1,14911 @@ +#ifndef OPENXR_H_ +#define OPENXR_H_ 1 + +/* +** Copyright 2017-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 OR MIT +*/ + +/* +** This header is generated from the Khronos OpenXR XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// XR_VERSION_1_0 is a preprocessor guard. Do not pass it to API calls. +#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, 1, 63) + +// OpenXR 1.0 version number +#define XR_API_VERSION_1_0 XR_MAKE_VERSION(1, 0, XR_VERSION_PATCH(XR_CURRENT_API_VERSION)) + +#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) + +#define XR_MIN_COMPOSITION_LAYERS_SUPPORTED 16 + + +#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) + + +#define XR_EXTENSION_ENUM_BASE 1000000000 + + +#define XR_EXTENSION_ENUM_STRIDE 1000 + + +#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_OPAQUE_64) + #if (XR_PTR_SIZE == 8) + #define XR_DEFINE_OPAQUE_64(object) typedef struct object##_T* object; + #else + #define XR_DEFINE_OPAQUE_64(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_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_EXTENSION_DEPENDENCY_NOT_ENABLED = -1000710001, + XR_ERROR_PERMISSION_INSUFFICIENT = -1000710000, + 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_SPACE_COMPONENT_NOT_SUPPORTED_FB = -1000113000, + XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB = -1000113001, + XR_ERROR_SPACE_COMPONENT_STATUS_PENDING_FB = -1000113002, + XR_ERROR_SPACE_COMPONENT_STATUS_ALREADY_SET_FB = -1000113003, + 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_MARKER_DETECTOR_PERMISSION_DENIED_ML = -1000138000, + XR_ERROR_MARKER_DETECTOR_LOCATE_FAILED_ML = -1000138001, + XR_ERROR_MARKER_DETECTOR_INVALID_DATA_QUERY_ML = -1000138002, + XR_ERROR_MARKER_DETECTOR_INVALID_CREATE_INFO_ML = -1000138003, + XR_ERROR_MARKER_INVALID_ML = -1000138004, + XR_ERROR_LOCALIZATION_MAP_INCOMPATIBLE_ML = -1000139000, + XR_ERROR_LOCALIZATION_MAP_UNAVAILABLE_ML = -1000139001, + XR_ERROR_LOCALIZATION_MAP_FAIL_ML = -1000139002, + XR_ERROR_LOCALIZATION_MAP_IMPORT_EXPORT_PERMISSION_DENIED_ML = -1000139003, + XR_ERROR_LOCALIZATION_MAP_PERMISSION_DENIED_ML = -1000139004, + XR_ERROR_LOCALIZATION_MAP_ALREADY_EXISTS_ML = -1000139005, + XR_ERROR_LOCALIZATION_MAP_CANNOT_EXPORT_CLOUD_MAP_ML = -1000139006, + XR_ERROR_SPATIAL_ANCHORS_PERMISSION_DENIED_ML = -1000140000, + XR_ERROR_SPATIAL_ANCHORS_NOT_LOCALIZED_ML = -1000140001, + XR_ERROR_SPATIAL_ANCHORS_OUT_OF_MAP_BOUNDS_ML = -1000140002, + XR_ERROR_SPATIAL_ANCHORS_SPACE_NOT_LOCATABLE_ML = -1000140003, + XR_ERROR_SPATIAL_ANCHORS_ANCHOR_NOT_FOUND_ML = -1000141000, + XR_ERROR_SPATIAL_ANCHOR_NAME_NOT_FOUND_MSFT = -1000142001, + XR_ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT = -1000142002, + XR_SCENE_MARKER_DATA_NOT_STRING_MSFT = 1000147000, + XR_ERROR_SPACE_MAPPING_INSUFFICIENT_FB = -1000169000, + XR_ERROR_SPACE_LOCALIZATION_FAILED_FB = -1000169001, + XR_ERROR_SPACE_NETWORK_TIMEOUT_FB = -1000169002, + XR_ERROR_SPACE_NETWORK_REQUEST_FAILED_FB = -1000169003, + XR_ERROR_SPACE_CLOUD_STORAGE_DISABLED_FB = -1000169004, + XR_ERROR_SPACE_INSUFFICIENT_RESOURCES_META = -1000259000, + XR_ERROR_SPACE_STORAGE_AT_CAPACITY_META = -1000259001, + XR_ERROR_SPACE_INSUFFICIENT_VIEW_META = -1000259002, + XR_ERROR_SPACE_PERMISSION_INSUFFICIENT_META = -1000259003, + XR_ERROR_SPACE_RATE_LIMITED_META = -1000259004, + XR_ERROR_SPACE_TOO_DARK_META = -1000259005, + XR_ERROR_SPACE_TOO_BRIGHT_META = -1000259006, + XR_ERROR_PASSTHROUGH_COLOR_LUT_BUFFER_SIZE_MISMATCH_META = -1000266000, + XR_ENVIRONMENT_DEPTH_NOT_AVAILABLE_META = 1000291000, + XR_ERROR_RENDER_MODEL_ID_INVALID_EXT = -1000300000, + XR_ERROR_RENDER_MODEL_ASSET_UNAVAILABLE_EXT = -1000300001, + XR_ERROR_RENDER_MODEL_GLTF_EXTENSION_REQUIRED_EXT = -1000300002, + XR_ERROR_NOT_INTERACTION_RENDER_MODEL_EXT = -1000301000, + XR_ERROR_HINT_ALREADY_SET_QCOM = -1000306000, + XR_ERROR_NOT_AN_ANCHOR_HTC = -1000319000, + XR_ERROR_SPATIAL_ENTITY_ID_INVALID_BD = -1000389000, + XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD = -1000389001, + XR_ERROR_ANCHOR_NOT_SUPPORTED_FOR_ENTITY_BD = -1000389002, + XR_ERROR_SPATIAL_ANCHOR_NOT_FOUND_BD = -1000390000, + XR_ERROR_SPATIAL_ANCHOR_SHARING_NETWORK_TIMEOUT_BD = -1000391000, + XR_ERROR_SPATIAL_ANCHOR_SHARING_AUTHENTICATION_FAILURE_BD = -1000391001, + XR_ERROR_SPATIAL_ANCHOR_SHARING_NETWORK_FAILURE_BD = -1000391002, + XR_ERROR_SPATIAL_ANCHOR_SHARING_LOCALIZATION_FAIL_BD = -1000391003, + XR_ERROR_SPATIAL_ANCHOR_SHARING_MAP_INSUFFICIENT_BD = -1000391004, + XR_ERROR_SCENE_CAPTURE_FAILURE_BD = -1000392000, + XR_ERROR_SPACE_NOT_LOCATABLE_EXT = -1000429000, + XR_ERROR_PLANE_DETECTION_PERMISSION_DENIED_EXT = -1000429001, + XR_ERROR_MISMATCHING_TRACKABLE_TYPE_ANDROID = -1000455000, + XR_ERROR_TRACKABLE_TYPE_NOT_SUPPORTED_ANDROID = -1000455001, + XR_ERROR_ANCHOR_ID_NOT_FOUND_ANDROID = -1000457000, + XR_ERROR_ANCHOR_ALREADY_PERSISTED_ANDROID = -1000457001, + XR_ERROR_ANCHOR_NOT_TRACKING_ANDROID = -1000457002, + XR_ERROR_PERSISTED_DATA_NOT_READY_ANDROID = -1000457003, + XR_ERROR_SERVICE_NOT_READY_ANDROID = -1000458000, + XR_ERROR_MESH_DATA_LIMIT_EXCEEDED_ANDROID = -1000462000, + XR_ERROR_FUTURE_PENDING_EXT = -1000469001, + XR_ERROR_FUTURE_INVALID_EXT = -1000469002, + XR_ERROR_SYSTEM_NOTIFICATION_PERMISSION_DENIED_ML = -1000473000, + XR_ERROR_SYSTEM_NOTIFICATION_INCOMPATIBLE_SKU_ML = -1000473001, + XR_ERROR_WORLD_MESH_DETECTOR_PERMISSION_DENIED_ML = -1000474000, + XR_ERROR_WORLD_MESH_DETECTOR_SPACE_NOT_LOCATABLE_ML = -1000474001, + XR_ERROR_FACIAL_EXPRESSION_PERMISSION_DENIED_ML = 1000482000, + XR_BOUNDARY_VISIBILITY_SUPPRESSION_NOT_ALLOWED_META = 1000528000, + XR_ERROR_COLOCATION_DISCOVERY_NETWORK_FAILED_META = -1000571001, + XR_ERROR_COLOCATION_DISCOVERY_NO_DISCOVERY_METHOD_META = -1000571002, + XR_COLOCATION_DISCOVERY_ALREADY_ADVERTISING_META = 1000571003, + XR_COLOCATION_DISCOVERY_ALREADY_DISCOVERING_META = 1000571004, + XR_ERROR_SPACE_GROUP_NOT_FOUND_META = -1000572002, + XR_ERROR_ANCHOR_NOT_OWNED_BY_CALLER_ANDROID = -1000701000, + XR_ERROR_IMAGE_FORMAT_UNSUPPORTED_ANDROID = -1000709000, + XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT = -1000740001, + XR_ERROR_SPATIAL_ENTITY_ID_INVALID_EXT = -1000740002, + XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT = -1000740003, + XR_ERROR_SPATIAL_COMPONENT_UNSUPPORTED_FOR_CAPABILITY_EXT = -1000740004, + XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT = -1000740005, + XR_ERROR_SPATIAL_COMPONENT_NOT_ENABLED_EXT = -1000740006, + XR_ERROR_CAMERA_UNAVAILABLE_BD = -1000755000, + XR_ERROR_CAMERA_OCCUPIED_BD = -1000755001, + XR_ERROR_CAMERA_CAPTURE_SESSION_CAPTURING_BD = -1000755002, + XR_ERROR_CAMERA_CAPTURE_SESSION_NOT_CAPTURING_BD = -1000755003, + XR_ERROR_CAMERA_ID_INVALID_BD = -1000755004, + XR_ERROR_CAMERA_IMAGE_ID_INVALID_BD = -1000755005, + XR_ERROR_CAMERA_PROPERTY_TYPE_INVALID_BD = -1000755006, + XR_ERROR_CAMERA_CAPABILITY_TYPE_INVALID_BD = -1000755007, + XR_ERROR_IMAGE_BUFFER_EXHAUSTED_BD = -1000755008, + XR_ERROR_SPATIAL_PERSISTENCE_SCOPE_UNSUPPORTED_EXT = -1000763001, + XR_ERROR_SPATIAL_PERSISTENCE_SCOPE_INCOMPATIBLE_EXT = -1000781001, + XR_ERROR_SPATIAL_IMAGE_FORMAT_UNSUPPORTED_EXT = -1000782001, + XR_ERROR_SPATIAL_IMAGE_INVALID_EXT = -1000782002, + XR_ERROR_SPATIAL_IMAGE_SIZE_MISSING_EXT = -1000782003, + XR_ERROR_KEYLESS_AUTH_NOT_SETUP_ANDROID = -1000787000, + XR_ERROR_KEYLESS_AUTH_FAILED_ANDROID = -1000787001, + XR_ERROR_GEOSPATIAL_TRACKER_NOT_RUNNING_ANDROID = -1000789000, + XR_ERROR_GEOSPATIAL_COORDINATES_INVALID_ANDROID = -1000789001, + XR_ERROR_GEOSPATIAL_CLOUD_AUTH_FAILED_ANDROID = -1000789002, + XR_ERROR_SPATIAL_ANCHOR_ATTACHABLE_COMPONENT_NOT_FOUND_ANDROID = -1000790001, + XR_ERROR_SPATIAL_ANCHOR_ENTITY_ID_INVALID_ANDROID = -1000795001, + XR_ERROR_SURFACE_ANCHOR_LOCATION_UNSUPPORTED_ANDROID = -1000797000, + XR_ERROR_SPATIAL_CONTAINER_CLOSED_EXT = -1000810000, + XR_ERROR_SPATIAL_CONTAINERS_ENABLED_EXT = -1000810001, + XR_ERROR_SPATIAL_CONTAINERS_NOT_ENABLED_EXT = -1000810002, + XR_ERROR_COMPATIBLE_SPATIAL_CONTAINER_MISSING_EXT = -1000810003, + XR_ERROR_SPATIAL_CONTAINER_IS_RENDERING_EXT = -1000813001, + XR_ERROR_SPATIAL_CONTAINER_NOT_RENDERING_EXT = -1000813002, + XR_ERROR_SPATIAL_CONTAINER_MISSING_EXT = -1000813003, + XR_ERROR_SPATIAL_CONTAINER_DUPLICATE_EXT = -1000813004, + XR_ERROR_SPATIAL_CONTAINER_GRAPHICS_PRESENTATION_MISSING_EXT = -1000813005, + XR_ERROR_EXTENSION_DEPENDENCY_NOT_ENABLED_KHR = XR_ERROR_EXTENSION_DEPENDENCY_NOT_ENABLED, + XR_ERROR_PERMISSION_INSUFFICIENT_KHR = XR_ERROR_PERMISSION_INSUFFICIENT, + 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_SPACES_LOCATE_INFO = 1000471000, + XR_TYPE_SPACE_LOCATIONS = 1000471001, + XR_TYPE_SPACE_VELOCITIES = 1000471002, + 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_GRAPHICS_BINDING_METAL_KHR = 1000029000, + XR_TYPE_SWAPCHAIN_IMAGE_METAL_KHR = 1000029001, + XR_TYPE_GRAPHICS_REQUIREMENTS_METAL_KHR = 1000029002, + 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_SPATIAL_GRAPH_STATIC_NODE_BINDING_CREATE_INFO_MSFT = 1000049001, + XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_GET_INFO_MSFT = 1000049002, + XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_MSFT = 1000049003, + 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_BODY_TRACKER_CREATE_INFO_FB = 1000076001, + XR_TYPE_BODY_JOINTS_LOCATE_INFO_FB = 1000076002, + XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_FB = 1000076004, + XR_TYPE_BODY_JOINT_LOCATIONS_FB = 1000076005, + XR_TYPE_BODY_SKELETON_FB = 1000076006, + XR_TYPE_INTERACTION_PROFILE_DPAD_BINDING_EXT = 1000078000, + 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_SYSTEM_SPATIAL_ENTITY_PROPERTIES_FB = 1000113004, + XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_FB = 1000113003, + XR_TYPE_SPACE_COMPONENT_STATUS_SET_INFO_FB = 1000113007, + XR_TYPE_SPACE_COMPONENT_STATUS_FB = 1000113001, + XR_TYPE_EVENT_DATA_SPATIAL_ANCHOR_CREATE_COMPLETE_FB = 1000113005, + XR_TYPE_EVENT_DATA_SPACE_SET_STATUS_COMPLETE_FB = 1000113006, + 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_SYSTEM_PASSTHROUGH_PROPERTIES2_FB = 1000118006, + 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_PASSTHROUGH_BRIGHTNESS_CONTRAST_SATURATION_FB = 1000118023, + 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_RENDER_MODEL_CAPABILITIES_REQUEST_FB = 1000119005, + 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_FRAME_END_INFO_ML = 1000135000, + XR_TYPE_GLOBAL_DIMMER_FRAME_END_INFO_ML = 1000136000, + XR_TYPE_COORDINATE_SPACE_CREATE_INFO_ML = 1000137000, + XR_TYPE_SYSTEM_MARKER_UNDERSTANDING_PROPERTIES_ML = 1000138000, + XR_TYPE_MARKER_DETECTOR_CREATE_INFO_ML = 1000138001, + XR_TYPE_MARKER_DETECTOR_ARUCO_INFO_ML = 1000138002, + XR_TYPE_MARKER_DETECTOR_SIZE_INFO_ML = 1000138003, + XR_TYPE_MARKER_DETECTOR_APRIL_TAG_INFO_ML = 1000138004, + XR_TYPE_MARKER_DETECTOR_CUSTOM_PROFILE_INFO_ML = 1000138005, + XR_TYPE_MARKER_DETECTOR_SNAPSHOT_INFO_ML = 1000138006, + XR_TYPE_MARKER_DETECTOR_STATE_ML = 1000138007, + XR_TYPE_MARKER_SPACE_CREATE_INFO_ML = 1000138008, + XR_TYPE_LOCALIZATION_MAP_ML = 1000139000, + XR_TYPE_EVENT_DATA_LOCALIZATION_CHANGED_ML = 1000139001, + XR_TYPE_MAP_LOCALIZATION_REQUEST_INFO_ML = 1000139002, + XR_TYPE_LOCALIZATION_MAP_IMPORT_INFO_ML = 1000139003, + XR_TYPE_LOCALIZATION_ENABLE_EVENTS_INFO_ML = 1000139004, + XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_POSE_ML = 1000140000, + XR_TYPE_CREATE_SPATIAL_ANCHORS_COMPLETION_ML = 1000140001, + XR_TYPE_SPATIAL_ANCHOR_STATE_ML = 1000140002, + XR_TYPE_SPATIAL_ANCHORS_CREATE_STORAGE_INFO_ML = 1000141000, + XR_TYPE_SPATIAL_ANCHORS_QUERY_INFO_RADIUS_ML = 1000141001, + XR_TYPE_SPATIAL_ANCHORS_QUERY_COMPLETION_ML = 1000141002, + XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_UUIDS_ML = 1000141003, + XR_TYPE_SPATIAL_ANCHORS_PUBLISH_INFO_ML = 1000141004, + XR_TYPE_SPATIAL_ANCHORS_PUBLISH_COMPLETION_ML = 1000141005, + XR_TYPE_SPATIAL_ANCHORS_DELETE_INFO_ML = 1000141006, + XR_TYPE_SPATIAL_ANCHORS_DELETE_COMPLETION_ML = 1000141007, + XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_INFO_ML = 1000141008, + XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_COMPLETION_ML = 1000141009, + XR_TYPE_SPATIAL_ANCHORS_PUBLISH_COMPLETION_DETAILS_ML = 1000141010, + XR_TYPE_SPATIAL_ANCHORS_DELETE_COMPLETION_DETAILS_ML = 1000141011, + XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_COMPLETION_DETAILS_ML = 1000141012, + XR_TYPE_EVENT_DATA_HEADSET_FIT_CHANGED_ML = 1000472000, + XR_TYPE_EVENT_DATA_EYE_CALIBRATION_CHANGED_ML = 1000472001, + XR_TYPE_USER_CALIBRATION_ENABLE_EVENTS_INFO_ML = 1000472002, + XR_TYPE_SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT = 1000142000, + XR_TYPE_SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_INFO_MSFT = 1000142001, + XR_TYPE_SCENE_MARKERS_MSFT = 1000147000, + XR_TYPE_SCENE_MARKER_TYPE_FILTER_MSFT = 1000147001, + XR_TYPE_SCENE_MARKER_QR_CODES_MSFT = 1000147002, + XR_TYPE_SPACE_QUERY_INFO_FB = 1000156001, + XR_TYPE_SPACE_QUERY_RESULTS_FB = 1000156002, + XR_TYPE_SPACE_STORAGE_LOCATION_FILTER_INFO_FB = 1000156003, + XR_TYPE_SPACE_UUID_FILTER_INFO_FB = 1000156054, + XR_TYPE_SPACE_COMPONENT_FILTER_INFO_FB = 1000156052, + XR_TYPE_EVENT_DATA_SPACE_QUERY_RESULTS_AVAILABLE_FB = 1000156103, + XR_TYPE_EVENT_DATA_SPACE_QUERY_COMPLETE_FB = 1000156104, + XR_TYPE_SPACE_SAVE_INFO_FB = 1000158000, + XR_TYPE_SPACE_ERASE_INFO_FB = 1000158001, + XR_TYPE_EVENT_DATA_SPACE_SAVE_COMPLETE_FB = 1000158106, + XR_TYPE_EVENT_DATA_SPACE_ERASE_COMPLETE_FB = 1000158107, + 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_SPACE_SHARE_INFO_FB = 1000169001, + XR_TYPE_EVENT_DATA_SPACE_SHARE_COMPLETE_FB = 1000169002, + XR_TYPE_COMPOSITION_LAYER_SPACE_WARP_INFO_FB = 1000171000, + XR_TYPE_SYSTEM_SPACE_WARP_PROPERTIES_FB = 1000171001, + XR_TYPE_HAPTIC_AMPLITUDE_ENVELOPE_VIBRATION_FB = 1000173001, + XR_TYPE_SEMANTIC_LABELS_FB = 1000175000, + XR_TYPE_ROOM_LAYOUT_FB = 1000175001, + XR_TYPE_BOUNDARY_2D_FB = 1000175002, + XR_TYPE_SEMANTIC_LABELS_SUPPORT_INFO_FB = 1000175010, + XR_TYPE_DIGITAL_LENS_CONTROL_ALMALENCE = 1000196000, + XR_TYPE_EVENT_DATA_SCENE_CAPTURE_COMPLETE_FB = 1000198001, + XR_TYPE_SCENE_CAPTURE_REQUEST_INFO_FB = 1000198050, + XR_TYPE_SPACE_CONTAINER_FB = 1000199000, + XR_TYPE_FOVEATION_EYE_TRACKED_PROFILE_CREATE_INFO_META = 1000200000, + XR_TYPE_FOVEATION_EYE_TRACKED_STATE_META = 1000200001, + XR_TYPE_SYSTEM_FOVEATION_EYE_TRACKED_PROPERTIES_META = 1000200002, + XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES_FB = 1000201004, + XR_TYPE_FACE_TRACKER_CREATE_INFO_FB = 1000201005, + XR_TYPE_FACE_EXPRESSION_INFO_FB = 1000201002, + XR_TYPE_FACE_EXPRESSION_WEIGHTS_FB = 1000201006, + XR_TYPE_EYE_TRACKER_CREATE_INFO_FB = 1000202001, + XR_TYPE_EYE_GAZES_INFO_FB = 1000202002, + XR_TYPE_EYE_GAZES_FB = 1000202003, + XR_TYPE_SYSTEM_EYE_TRACKING_PROPERTIES_FB = 1000202004, + XR_TYPE_PASSTHROUGH_KEYBOARD_HANDS_INTENSITY_FB = 1000203002, + XR_TYPE_COMPOSITION_LAYER_SETTINGS_FB = 1000204000, + XR_TYPE_HAPTIC_PCM_VIBRATION_FB = 1000209001, + XR_TYPE_DEVICE_PCM_SAMPLE_RATE_STATE_FB = 1000209002, + XR_TYPE_FRAME_SYNTHESIS_INFO_EXT = 1000211000, + XR_TYPE_FRAME_SYNTHESIS_CONFIG_VIEW_EXT = 1000211001, + XR_TYPE_COMPOSITION_LAYER_DEPTH_TEST_FB = 1000212000, + XR_TYPE_LOCAL_DIMMING_FRAME_END_INFO_META = 1000216000, + XR_TYPE_PASSTHROUGH_PREFERENCES_META = 1000217000, + XR_TYPE_SYSTEM_VIRTUAL_KEYBOARD_PROPERTIES_META = 1000219001, + XR_TYPE_VIRTUAL_KEYBOARD_CREATE_INFO_META = 1000219002, + XR_TYPE_VIRTUAL_KEYBOARD_SPACE_CREATE_INFO_META = 1000219003, + XR_TYPE_VIRTUAL_KEYBOARD_LOCATION_INFO_META = 1000219004, + XR_TYPE_VIRTUAL_KEYBOARD_MODEL_VISIBILITY_SET_INFO_META = 1000219005, + XR_TYPE_VIRTUAL_KEYBOARD_ANIMATION_STATE_META = 1000219006, + XR_TYPE_VIRTUAL_KEYBOARD_MODEL_ANIMATION_STATES_META = 1000219007, + XR_TYPE_VIRTUAL_KEYBOARD_TEXTURE_DATA_META = 1000219009, + XR_TYPE_VIRTUAL_KEYBOARD_INPUT_INFO_META = 1000219010, + XR_TYPE_VIRTUAL_KEYBOARD_TEXT_CONTEXT_CHANGE_INFO_META = 1000219011, + XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_COMMIT_TEXT_META = 1000219014, + XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_BACKSPACE_META = 1000219015, + XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_ENTER_META = 1000219016, + XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_SHOWN_META = 1000219017, + XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_HIDDEN_META = 1000219018, + XR_TYPE_EXTERNAL_CAMERA_OCULUS = 1000226000, + XR_TYPE_VULKAN_SWAPCHAIN_CREATE_INFO_META = 1000227000, + XR_TYPE_PERFORMANCE_METRICS_STATE_META = 1000232001, + XR_TYPE_PERFORMANCE_METRICS_COUNTER_META = 1000232002, + XR_TYPE_SPACE_LIST_SAVE_INFO_FB = 1000238000, + XR_TYPE_EVENT_DATA_SPACE_LIST_SAVE_COMPLETE_FB = 1000238001, + XR_TYPE_SPACE_USER_CREATE_INFO_FB = 1000241001, + XR_TYPE_SYSTEM_HEADSET_ID_PROPERTIES_META = 1000245000, + XR_TYPE_SYSTEM_SPACE_DISCOVERY_PROPERTIES_META = 1000247000, + XR_TYPE_SPACE_DISCOVERY_INFO_META = 1000247001, + XR_TYPE_SPACE_FILTER_UUID_META = 1000247003, + XR_TYPE_SPACE_FILTER_COMPONENT_META = 1000247004, + XR_TYPE_SPACE_DISCOVERY_RESULT_META = 1000247005, + XR_TYPE_SPACE_DISCOVERY_RESULTS_META = 1000247006, + XR_TYPE_EVENT_DATA_SPACE_DISCOVERY_RESULTS_AVAILABLE_META = 1000247007, + XR_TYPE_EVENT_DATA_SPACE_DISCOVERY_COMPLETE_META = 1000247008, + XR_TYPE_RECOMMENDED_LAYER_RESOLUTION_META = 1000254000, + XR_TYPE_RECOMMENDED_LAYER_RESOLUTION_GET_INFO_META = 1000254001, + XR_TYPE_SYSTEM_SPACE_PERSISTENCE_PROPERTIES_META = 1000259000, + XR_TYPE_SPACES_SAVE_INFO_META = 1000259001, + XR_TYPE_EVENT_DATA_SPACES_SAVE_RESULT_META = 1000259002, + XR_TYPE_SPACES_ERASE_INFO_META = 1000259003, + XR_TYPE_EVENT_DATA_SPACES_ERASE_RESULT_META = 1000259004, + XR_TYPE_SYSTEM_PASSTHROUGH_COLOR_LUT_PROPERTIES_META = 1000266000, + XR_TYPE_PASSTHROUGH_COLOR_LUT_CREATE_INFO_META = 1000266001, + XR_TYPE_PASSTHROUGH_COLOR_LUT_UPDATE_INFO_META = 1000266002, + XR_TYPE_PASSTHROUGH_COLOR_MAP_LUT_META = 1000266100, + XR_TYPE_PASSTHROUGH_COLOR_MAP_INTERPOLATED_LUT_META = 1000266101, + XR_TYPE_SPACE_TRIANGLE_MESH_GET_INFO_META = 1000269001, + XR_TYPE_SPACE_TRIANGLE_MESH_META = 1000269002, + XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_FULL_BODY_META = 1000274000, + XR_TYPE_EVENT_DATA_PASSTHROUGH_LAYER_RESUMED_META = 1000282000, + XR_TYPE_BODY_TRACKING_CALIBRATION_INFO_META = 1000283002, + XR_TYPE_BODY_TRACKING_CALIBRATION_STATUS_META = 1000283003, + XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_CALIBRATION_META = 1000283004, + XR_TYPE_BODY_TRACKING_FIDELITY_STATUS_META = 1000284000, + XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_FIDELITY_META = 1000284001, + XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES2_FB = 1000287013, + XR_TYPE_FACE_TRACKER_CREATE_INFO2_FB = 1000287014, + XR_TYPE_FACE_EXPRESSION_INFO2_FB = 1000287015, + XR_TYPE_FACE_EXPRESSION_WEIGHTS2_FB = 1000287016, + XR_TYPE_SYSTEM_SPATIAL_ENTITY_SHARING_PROPERTIES_META = 1000290000, + XR_TYPE_SHARE_SPACES_INFO_META = 1000290001, + XR_TYPE_EVENT_DATA_SHARE_SPACES_COMPLETE_META = 1000290002, + XR_TYPE_ENVIRONMENT_DEPTH_PROVIDER_CREATE_INFO_META = 1000291000, + XR_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_CREATE_INFO_META = 1000291001, + XR_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_STATE_META = 1000291002, + XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_ACQUIRE_INFO_META = 1000291003, + XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_VIEW_META = 1000291004, + XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_META = 1000291005, + XR_TYPE_ENVIRONMENT_DEPTH_HAND_REMOVAL_SET_INFO_META = 1000291006, + XR_TYPE_SYSTEM_ENVIRONMENT_DEPTH_PROPERTIES_META = 1000291007, + XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_TIMESTAMP_META = 1000291008, + XR_TYPE_RENDER_MODEL_CREATE_INFO_EXT = 1000300000, + XR_TYPE_RENDER_MODEL_PROPERTIES_GET_INFO_EXT = 1000300001, + XR_TYPE_RENDER_MODEL_PROPERTIES_EXT = 1000300002, + XR_TYPE_RENDER_MODEL_SPACE_CREATE_INFO_EXT = 1000300003, + XR_TYPE_RENDER_MODEL_STATE_GET_INFO_EXT = 1000300004, + XR_TYPE_RENDER_MODEL_STATE_EXT = 1000300005, + XR_TYPE_RENDER_MODEL_ASSET_CREATE_INFO_EXT = 1000300006, + XR_TYPE_RENDER_MODEL_ASSET_DATA_GET_INFO_EXT = 1000300007, + XR_TYPE_RENDER_MODEL_ASSET_DATA_EXT = 1000300008, + XR_TYPE_RENDER_MODEL_ASSET_PROPERTIES_GET_INFO_EXT = 1000300009, + XR_TYPE_RENDER_MODEL_ASSET_PROPERTIES_EXT = 1000300010, + XR_TYPE_INTERACTION_RENDER_MODEL_IDS_ENUMERATE_INFO_EXT = 1000301000, + XR_TYPE_INTERACTION_RENDER_MODEL_SUBACTION_PATH_INFO_EXT = 1000301001, + XR_TYPE_EVENT_DATA_INTERACTION_RENDER_MODELS_CHANGED_EXT = 1000301002, + XR_TYPE_INTERACTION_RENDER_MODEL_TOP_LEVEL_USER_PATH_GET_INFO_EXT = 1000301003, + XR_TYPE_PASSTHROUGH_CREATE_INFO_HTC = 1000317001, + XR_TYPE_PASSTHROUGH_COLOR_HTC = 1000317002, + XR_TYPE_PASSTHROUGH_MESH_TRANSFORM_INFO_HTC = 1000317003, + XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_HTC = 1000317004, + XR_TYPE_FOVEATION_APPLY_INFO_HTC = 1000318000, + XR_TYPE_FOVEATION_DYNAMIC_MODE_INFO_HTC = 1000318001, + XR_TYPE_FOVEATION_CUSTOM_MODE_INFO_HTC = 1000318002, + XR_TYPE_SYSTEM_ANCHOR_PROPERTIES_HTC = 1000319000, + XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_HTC = 1000319001, + XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_HTC = 1000320000, + XR_TYPE_BODY_TRACKER_CREATE_INFO_HTC = 1000320001, + XR_TYPE_BODY_JOINTS_LOCATE_INFO_HTC = 1000320002, + XR_TYPE_BODY_JOINT_LOCATIONS_HTC = 1000320003, + XR_TYPE_BODY_SKELETON_HTC = 1000320004, + XR_TYPE_ACTIVE_ACTION_SET_PRIORITIES_EXT = 1000373000, + XR_TYPE_SYSTEM_FORCE_FEEDBACK_CURL_PROPERTIES_MNDX = 1000375000, + XR_TYPE_FORCE_FEEDBACK_CURL_APPLY_LOCATIONS_MNDX = 1000375001, + XR_TYPE_BODY_TRACKER_CREATE_INFO_BD = 1000385001, + XR_TYPE_BODY_JOINTS_LOCATE_INFO_BD = 1000385002, + XR_TYPE_BODY_JOINT_LOCATIONS_BD = 1000385003, + XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_BD = 1000385004, + XR_TYPE_SYSTEM_FACIAL_SIMULATION_PROPERTIES_BD = 1000386001, + XR_TYPE_FACE_TRACKER_CREATE_INFO_BD = 1000386002, + XR_TYPE_FACIAL_SIMULATION_DATA_GET_INFO_BD = 1000386003, + XR_TYPE_FACIAL_SIMULATION_DATA_BD = 1000386004, + XR_TYPE_LIP_EXPRESSION_DATA_BD = 1000386005, + XR_TYPE_SYSTEM_SPATIAL_SENSING_PROPERTIES_BD = 1000389000, + XR_TYPE_SPATIAL_ENTITY_COMPONENT_GET_INFO_BD = 1000389001, + XR_TYPE_SPATIAL_ENTITY_LOCATION_GET_INFO_BD = 1000389002, + XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_LOCATION_BD = 1000389003, + XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_SEMANTIC_BD = 1000389004, + XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_BOUNDING_BOX_2D_BD = 1000389005, + XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_POLYGON_BD = 1000389006, + XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_BOUNDING_BOX_3D_BD = 1000389007, + XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_TRIANGLE_MESH_BD = 1000389008, + XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_BD = 1000389009, + XR_TYPE_SENSE_DATA_PROVIDER_START_INFO_BD = 1000389010, + XR_TYPE_EVENT_DATA_SENSE_DATA_PROVIDER_STATE_CHANGED_BD = 1000389011, + XR_TYPE_EVENT_DATA_SENSE_DATA_UPDATED_BD = 1000389012, + XR_TYPE_SENSE_DATA_QUERY_INFO_BD = 1000389013, + XR_TYPE_SENSE_DATA_QUERY_COMPLETION_BD = 1000389014, + XR_TYPE_SENSE_DATA_FILTER_UUID_BD = 1000389015, + XR_TYPE_SENSE_DATA_FILTER_SEMANTIC_BD = 1000389016, + XR_TYPE_QUERIED_SENSE_DATA_GET_INFO_BD = 1000389017, + XR_TYPE_QUERIED_SENSE_DATA_BD = 1000389018, + XR_TYPE_SPATIAL_ENTITY_STATE_BD = 1000389019, + XR_TYPE_SPATIAL_ENTITY_ANCHOR_CREATE_INFO_BD = 1000389020, + XR_TYPE_ANCHOR_SPACE_CREATE_INFO_BD = 1000389021, + XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_SPHERE_BD = 1000389022, + XR_TYPE_SYSTEM_SPATIAL_ANCHOR_PROPERTIES_BD = 1000390000, + XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_BD = 1000390001, + XR_TYPE_SPATIAL_ANCHOR_CREATE_COMPLETION_BD = 1000390002, + XR_TYPE_SPATIAL_ANCHOR_PERSIST_INFO_BD = 1000390003, + XR_TYPE_SPATIAL_ANCHOR_UNPERSIST_INFO_BD = 1000390004, + XR_TYPE_SYSTEM_SPATIAL_ANCHOR_SHARING_PROPERTIES_BD = 1000391000, + XR_TYPE_SPATIAL_ANCHOR_SHARE_INFO_BD = 1000391001, + XR_TYPE_SHARED_SPATIAL_ANCHOR_DOWNLOAD_INFO_BD = 1000391002, + XR_TYPE_SYSTEM_SPATIAL_SCENE_PROPERTIES_BD = 1000392000, + XR_TYPE_SCENE_CAPTURE_INFO_BD = 1000392001, + XR_TYPE_SYSTEM_SPATIAL_MESH_PROPERTIES_BD = 1000393000, + XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_SPATIAL_MESH_BD = 1000393001, + XR_TYPE_FUTURE_POLL_RESULT_PROGRESS_BD = 1000394001, + XR_TYPE_BODY_TRACKING_POSTURE_DATA_BD = 1000395001, + XR_TYPE_BODY_JOINT_VELOCITIES_BD = 1000395002, + XR_TYPE_BODY_JOINT_ACCELERATIONS_BD = 1000395003, + XR_TYPE_BODY_TRACKING_STATE_BD = 1000395004, + XR_TYPE_SYSTEM_SPATIAL_PLANE_PROPERTIES_BD = 1000396000, + XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_PLANE_ORIENTATION_BD = 1000396001, + XR_TYPE_SENSE_DATA_FILTER_PLANE_ORIENTATION_BD = 1000396002, + XR_TYPE_SYSTEM_LIGHT_ESTIMATION_PROPERTIES_BD = 1000397000, + XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_LIGHT_ESTIMATION_BD = 1000397001, + XR_TYPE_ENVIRONMENT_TEXTURE_CREATE_CONFIG_INFO_BD = 1000397002, + XR_TYPE_LIGHT_ESTIMATION_DATA_ENVIRONMENT_TEXTURE_RAW_BD = 1000397003, + XR_TYPE_LIGHT_ESTIMATION_DATA_SPHERICAL_HARMONICS_BD = 1000397005, + XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_LIGHT_ESTIMATION_BD = 1000397006, + XR_TYPE_SPATIAL_AUDIO_RENDERER_CREATE_INFO_BD = 1000409000, + XR_TYPE_AUDIO_BUFFER_BD = 1000409001, + XR_TYPE_SOUND_OBJECT_DIRECTIVITY_CARDIOID_BD = 1000409003, + XR_TYPE_SOUND_OBJECT_SHAPE_SPHERE_BD = 1000409004, + XR_TYPE_SOUND_OBJECT_DISTANCE_ATTENUATION_BD = 1000409005, + XR_TYPE_SOUND_OBJECT_DISTANCE_ATTENUATION_CURVE_BD = 1000409006, + XR_TYPE_SOUND_OBJECT_CONFIG_BD = 1000409007, + XR_TYPE_SOUND_FIELD_CONFIG_BD = 1000409008, + XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_SURROUND_BD = 1000409009, + XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_AMBIX_BD = 1000409010, + XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_FUMA_BD = 1000409011, + XR_TYPE_SOUND_TRIANGLE_MESH_BD = 1000409012, + XR_TYPE_SOUND_OBSTACLE_CONFIG_BD = 1000409013, + XR_TYPE_SOUND_OBSTACLE_MATERIAL_CONFIG_BD = 1000409014, + XR_TYPE_HAND_TRACKING_DATA_SOURCE_INFO_EXT = 1000428000, + XR_TYPE_HAND_TRACKING_DATA_SOURCE_STATE_EXT = 1000428001, + XR_TYPE_PLANE_DETECTOR_CREATE_INFO_EXT = 1000429001, + XR_TYPE_PLANE_DETECTOR_BEGIN_INFO_EXT = 1000429002, + XR_TYPE_PLANE_DETECTOR_GET_INFO_EXT = 1000429003, + XR_TYPE_PLANE_DETECTOR_LOCATIONS_EXT = 1000429004, + XR_TYPE_PLANE_DETECTOR_LOCATION_EXT = 1000429005, + XR_TYPE_PLANE_DETECTOR_POLYGON_BUFFER_EXT = 1000429006, + XR_TYPE_SYSTEM_PLANE_DETECTION_PROPERTIES_EXT = 1000429007, + XR_TYPE_TRACKABLE_GET_INFO_ANDROID = 1000455000, + XR_TYPE_ANCHOR_SPACE_CREATE_INFO_ANDROID = 1000455001, + XR_TYPE_TRACKABLE_PLANE_ANDROID = 1000455003, + XR_TYPE_TRACKABLE_TRACKER_CREATE_INFO_ANDROID = 1000455004, + XR_TYPE_SYSTEM_TRACKABLES_PROPERTIES_ANDROID = 1000455005, + XR_TYPE_EYES_ANDROID = 1000456000, + XR_TYPE_EYE_TRACKER_CREATE_INFO_ANDROID = 1000456001, + XR_TYPE_EYES_GET_INFO_ANDROID = 1000456002, + XR_TYPE_SYSTEM_EYE_TRACKING_PROPERTIES_ANDROID = 1000456004, + XR_TYPE_PERSISTED_ANCHOR_SPACE_CREATE_INFO_ANDROID = 1000457001, + XR_TYPE_PERSISTED_ANCHOR_SPACE_INFO_ANDROID = 1000457002, + XR_TYPE_DEVICE_ANCHOR_PERSISTENCE_CREATE_INFO_ANDROID = 1000457003, + XR_TYPE_SYSTEM_DEVICE_ANCHOR_PERSISTENCE_PROPERTIES_ANDROID = 1000457004, + XR_TYPE_FACE_TRACKER_CREATE_INFO_ANDROID = 1000458000, + XR_TYPE_FACE_STATE_GET_INFO_ANDROID = 1000458001, + XR_TYPE_FACE_STATE_ANDROID = 1000458002, + XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES_ANDROID = 1000458003, + XR_TYPE_PASSTHROUGH_CAMERA_STATE_GET_INFO_ANDROID = 1000460000, + XR_TYPE_SYSTEM_PASSTHROUGH_CAMERA_STATE_PROPERTIES_ANDROID = 1000460001, + XR_TYPE_EVENT_DATA_RECOMMENDED_RESOLUTION_CHANGED_ANDROID = 1000461000, + XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_ANDROID = 1000462000, + XR_TYPE_PASSTHROUGH_LAYER_MESH_ANDROID = 1000462001, + XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_ANDROID = 1000462002, + XR_TYPE_SYSTEM_PASSTHROUGH_LAYER_PROPERTIES_ANDROID = 1000462003, + XR_TYPE_RAYCAST_INFO_ANDROID = 1000463000, + XR_TYPE_RAYCAST_HIT_RESULTS_ANDROID = 1000463001, + XR_TYPE_PERFORMANCE_METRICS_STATE_ANDROID = 1000465000, + XR_TYPE_PERFORMANCE_METRICS_COUNTER_ANDROID = 1000465001, + XR_TYPE_TRACKABLE_OBJECT_ANDROID = 1000466000, + XR_TYPE_TRACKABLE_OBJECT_CONFIGURATION_ANDROID = 1000466001, + XR_TYPE_FUTURE_CANCEL_INFO_EXT = 1000469000, + XR_TYPE_FUTURE_POLL_INFO_EXT = 1000469001, + XR_TYPE_FUTURE_COMPLETION_EXT = 1000469002, + XR_TYPE_FUTURE_POLL_RESULT_EXT = 1000469003, + XR_TYPE_EVENT_DATA_USER_PRESENCE_CHANGED_EXT = 1000470000, + XR_TYPE_SYSTEM_USER_PRESENCE_PROPERTIES_EXT = 1000470001, + XR_TYPE_SYSTEM_NOTIFICATIONS_SET_INFO_ML = 1000473000, + XR_TYPE_WORLD_MESH_DETECTOR_CREATE_INFO_ML = 1000474001, + XR_TYPE_WORLD_MESH_STATE_REQUEST_INFO_ML = 1000474002, + XR_TYPE_WORLD_MESH_BLOCK_STATE_ML = 1000474003, + XR_TYPE_WORLD_MESH_STATE_REQUEST_COMPLETION_ML = 1000474004, + XR_TYPE_WORLD_MESH_BUFFER_RECOMMENDED_SIZE_INFO_ML = 1000474005, + XR_TYPE_WORLD_MESH_BUFFER_SIZE_ML = 1000474006, + XR_TYPE_WORLD_MESH_BUFFER_ML = 1000474007, + XR_TYPE_WORLD_MESH_BLOCK_REQUEST_ML = 1000474008, + XR_TYPE_WORLD_MESH_GET_INFO_ML = 1000474009, + XR_TYPE_WORLD_MESH_BLOCK_ML = 1000474010, + XR_TYPE_WORLD_MESH_REQUEST_COMPLETION_ML = 1000474011, + XR_TYPE_WORLD_MESH_REQUEST_COMPLETION_INFO_ML = 1000474012, + XR_TYPE_SYSTEM_FACIAL_EXPRESSION_PROPERTIES_ML = 1000482004, + XR_TYPE_FACIAL_EXPRESSION_CLIENT_CREATE_INFO_ML = 1000482005, + XR_TYPE_FACIAL_EXPRESSION_BLEND_SHAPE_GET_INFO_ML = 1000482006, + XR_TYPE_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_ML = 1000482007, + XR_TYPE_SYSTEM_BOUNDARY_VISIBILITY_PROPERTIES_META = 1000528000, + XR_TYPE_EVENT_DATA_BOUNDARY_VISIBILITY_CHANGED_META = 1000528001, + XR_TYPE_SYSTEM_SIMULTANEOUS_HANDS_AND_CONTROLLERS_PROPERTIES_META = 1000532001, + XR_TYPE_SIMULTANEOUS_HANDS_AND_CONTROLLERS_TRACKING_RESUME_INFO_META = 1000532002, + XR_TYPE_SIMULTANEOUS_HANDS_AND_CONTROLLERS_TRACKING_PAUSE_INFO_META = 1000532003, + XR_TYPE_FACE_TRACKING_VISEMES_META = 1000541000, + XR_TYPE_SYSTEM_FACE_TRACKING_VISEMES_PROPERTIES_META = 1000541001, + XR_TYPE_ROOM_MESH_FACE_INDICES_META = 1000553000, + XR_TYPE_SPACE_ROOM_MESH_GET_INFO_META = 1000553001, + XR_TYPE_ROOM_MESH_META = 1000553002, + XR_TYPE_COLOCATION_DISCOVERY_START_INFO_META = 1000571010, + XR_TYPE_COLOCATION_DISCOVERY_STOP_INFO_META = 1000571011, + XR_TYPE_COLOCATION_ADVERTISEMENT_START_INFO_META = 1000571012, + XR_TYPE_COLOCATION_ADVERTISEMENT_STOP_INFO_META = 1000571013, + XR_TYPE_EVENT_DATA_START_COLOCATION_ADVERTISEMENT_COMPLETE_META = 1000571020, + XR_TYPE_EVENT_DATA_STOP_COLOCATION_ADVERTISEMENT_COMPLETE_META = 1000571021, + XR_TYPE_EVENT_DATA_COLOCATION_ADVERTISEMENT_COMPLETE_META = 1000571022, + XR_TYPE_EVENT_DATA_START_COLOCATION_DISCOVERY_COMPLETE_META = 1000571023, + XR_TYPE_EVENT_DATA_COLOCATION_DISCOVERY_RESULT_META = 1000571024, + XR_TYPE_EVENT_DATA_COLOCATION_DISCOVERY_COMPLETE_META = 1000571025, + XR_TYPE_EVENT_DATA_STOP_COLOCATION_DISCOVERY_COMPLETE_META = 1000571026, + XR_TYPE_SYSTEM_COLOCATION_DISCOVERY_PROPERTIES_META = 1000571030, + XR_TYPE_SHARE_SPACES_RECIPIENT_GROUPS_META = 1000572000, + XR_TYPE_SPACE_GROUP_UUID_FILTER_INFO_META = 1000572001, + XR_TYPE_SYSTEM_SPATIAL_ENTITY_GROUP_SHARING_PROPERTIES_META = 1000572100, + XR_TYPE_SYSTEM_ENVIRONMENT_RAYCAST_PROPERTIES_META = 1000592000, + XR_TYPE_ENVIRONMENT_RAYCASTER_CREATE_INFO_META = 1000592001, + XR_TYPE_ENVIRONMENT_RAYCASTER_CREATE_COMPLETION_META = 1000592002, + XR_TYPE_ENVIRONMENT_RAYCAST_HIT_GET_INFO_META = 1000592003, + XR_TYPE_ENVIRONMENT_RAYCAST_HIT_META = 1000592004, + XR_TYPE_ENVIRONMENT_RAYCAST_FILTER_DISTANCE_META = 1000592005, + XR_TYPE_TILE_PROPERTIES_META = 1000609000, + XR_TYPE_TILE_PROPERTIES_HINT_META = 1000609001, + XR_TYPE_HAND_TRACKING_UNEXTRAPOLATED_POSES_REQUEST_META = 1000693000, + XR_TYPE_HAND_TRACKING_UNEXTRAPOLATED_POSES_META = 1000693001, + XR_TYPE_LIGHT_ESTIMATOR_CREATE_INFO_ANDROID = 1000700000, + XR_TYPE_LIGHT_ESTIMATE_GET_INFO_ANDROID = 1000700001, + XR_TYPE_LIGHT_ESTIMATE_ANDROID = 1000700002, + XR_TYPE_DIRECTIONAL_LIGHT_ANDROID = 1000700003, + XR_TYPE_SPHERICAL_HARMONICS_ANDROID = 1000700004, + XR_TYPE_AMBIENT_LIGHT_ANDROID = 1000700005, + XR_TYPE_SYSTEM_LIGHT_ESTIMATION_PROPERTIES_ANDROID = 1000700006, + XR_TYPE_ANCHOR_SHARING_INFO_ANDROID = 1000701000, + XR_TYPE_ANCHOR_SHARING_TOKEN_ANDROID = 1000701001, + XR_TYPE_SYSTEM_ANCHOR_SHARING_EXPORT_PROPERTIES_ANDROID = 1000701002, + XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_ANDROID = 1000707000, + XR_TYPE_TRACKABLE_MARKER_CONFIGURATION_ANDROID = 1000707001, + XR_TYPE_TRACKABLE_MARKER_ANDROID = 1000707002, + XR_TYPE_SYSTEM_QR_CODE_TRACKING_PROPERTIES_ANDROID = 1000708000, + XR_TYPE_TRACKABLE_QR_CODE_CONFIGURATION_ANDROID = 1000708001, + XR_TYPE_TRACKABLE_QR_CODE_ANDROID = 1000708002, + XR_TYPE_SYSTEM_IMAGE_TRACKING_PROPERTIES_ANDROID = 1000709000, + XR_TYPE_TRACKABLE_IMAGE_DATABASE_ENTRY_ANDROID = 1000709001, + XR_TYPE_TRACKABLE_IMAGE_DATABASE_CREATE_INFO_ANDROID = 1000709002, + XR_TYPE_CREATE_TRACKABLE_IMAGE_DATABASE_COMPLETION_ANDROID = 1000709003, + XR_TYPE_TRACKABLE_IMAGE_CONFIGURATION_ANDROID = 1000709004, + XR_TYPE_TRACKABLE_IMAGE_ANDROID = 1000709005, + XR_TYPE_EVENT_DATA_IMAGE_TRACKING_LOST_ANDROID = 1000709006, + XR_TYPE_SYSTEM_SCENE_MESHING_PROPERTIES_ANDROID = 1000718000, + XR_TYPE_SCENE_MESHING_TRACKER_CREATE_INFO_ANDROID = 1000718001, + XR_TYPE_SCENE_MESH_SNAPSHOT_CREATE_INFO_ANDROID = 1000718002, + XR_TYPE_SCENE_MESH_SNAPSHOT_CREATION_RESULT_ANDROID = 1000718003, + XR_TYPE_SCENE_SUBMESH_STATE_ANDROID = 1000718004, + XR_TYPE_SCENE_SUBMESH_DATA_ANDROID = 1000718005, + XR_TYPE_SPATIAL_CAPABILITY_COMPONENT_TYPES_EXT = 1000740000, + XR_TYPE_SPATIAL_CONTEXT_CREATE_INFO_EXT = 1000740001, + XR_TYPE_CREATE_SPATIAL_CONTEXT_COMPLETION_EXT = 1000740002, + XR_TYPE_SPATIAL_DISCOVERY_SNAPSHOT_CREATE_INFO_EXT = 1000740003, + XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_INFO_EXT = 1000740004, + XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_EXT = 1000740005, + XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_CONDITION_EXT = 1000740006, + XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_RESULT_EXT = 1000740007, + XR_TYPE_SPATIAL_BUFFER_GET_INFO_EXT = 1000740008, + XR_TYPE_SPATIAL_COMPONENT_BOUNDED_2D_LIST_EXT = 1000740009, + XR_TYPE_SPATIAL_COMPONENT_BOUNDED_3D_LIST_EXT = 1000740010, + XR_TYPE_SPATIAL_COMPONENT_PARENT_LIST_EXT = 1000740011, + XR_TYPE_SPATIAL_COMPONENT_MESH_3D_LIST_EXT = 1000740012, + XR_TYPE_SPATIAL_ENTITY_FROM_ID_CREATE_INFO_EXT = 1000740013, + XR_TYPE_SPATIAL_UPDATE_SNAPSHOT_CREATE_INFO_EXT = 1000740014, + XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT = 1000740015, + XR_TYPE_SPATIAL_FILTER_TRACKING_STATE_EXT = 1000740016, + XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_PLANE_TRACKING_EXT = 1000741000, + XR_TYPE_SPATIAL_COMPONENT_PLANE_ALIGNMENT_LIST_EXT = 1000741001, + XR_TYPE_SPATIAL_COMPONENT_MESH_2D_LIST_EXT = 1000741002, + XR_TYPE_SPATIAL_COMPONENT_POLYGON_2D_LIST_EXT = 1000741003, + XR_TYPE_SPATIAL_COMPONENT_PLANE_SEMANTIC_LABEL_LIST_EXT = 1000741004, + XR_TYPE_STATIONARY_REFERENCE_SPACE_GENERATION_ID_GET_INFO_EXT = 1000742001, + XR_TYPE_STATIONARY_REFERENCE_SPACE_GENERATION_ID_RESULT_EXT = 1000742002, + XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_QR_CODE_EXT = 1000743000, + XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_MICRO_QR_CODE_EXT = 1000743001, + XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ARUCO_MARKER_EXT = 1000743002, + XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_APRIL_TAG_EXT = 1000743003, + XR_TYPE_SPATIAL_MARKER_SIZE_EXT = 1000743004, + XR_TYPE_SPATIAL_MARKER_STATIC_OPTIMIZATION_EXT = 1000743005, + XR_TYPE_SPATIAL_COMPONENT_MARKER_LIST_EXT = 1000743006, + XR_TYPE_SYSTEM_DYNAMIC_OBJECT_TRACKING_PROPERTIES_BD = 1000746000, + XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_DYNAMIC_OBJECT_BD = 1000746001, + XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_DYNAMIC_OBJECT_BD = 1000746002, + XR_TYPE_DYNAMIC_OBJECT_DATA_BD = 1000746003, + XR_TYPE_SENSE_DATA_FILTER_DYNAMIC_OBJECT_TYPE_BD = 1000746004, + XR_TYPE_SYSTEM_DYNAMIC_OBJECT_KEYBOARD_PROPERTIES_BD = 1000747000, + XR_TYPE_SYSTEM_DYNAMIC_OBJECT_MOUSE_PROPERTIES_BD = 1000748000, + XR_TYPE_AVAILABLE_CAMERAS_ENUMERATE_INFO_BD = 1000755000, + XR_TYPE_CAMERA_PROPERTIES_GET_INFO_BD = 1000755001, + XR_TYPE_CAMERA_PROPERTIES_BD = 1000755002, + XR_TYPE_CAMERA_PROPERTY_FACING_BD = 1000755003, + XR_TYPE_CAMERA_PROPERTY_POSITION_BD = 1000755004, + XR_TYPE_CAMERA_PROPERTY_CAMERA_TYPE_BD = 1000755005, + XR_TYPE_CAMERA_SUPPORTED_CAPABILITIES_GET_INFO_BD = 1000755006, + XR_TYPE_CAMERA_SUPPORTED_CAPABILITIES_BD = 1000755007, + XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_IMAGE_RESOLUTION_AND_FRAME_RATE_BD = 1000755008, + XR_TYPE_CAMERA_CAPABILITY_IMAGE_RESOLUTION_AND_FRAME_RATE_BD = 1000755009, + XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_DATA_TRANSFER_TYPE_BD = 1000755010, + XR_TYPE_CAMERA_CAPABILITY_DATA_TRANSFER_TYPE_BD = 1000755011, + XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_IMAGE_FORMAT_BD = 1000755012, + XR_TYPE_CAMERA_CAPABILITY_IMAGE_FORMAT_BD = 1000755013, + XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_CAMERA_MODEL_BD = 1000755014, + XR_TYPE_CAMERA_CAPABILITY_CAMERA_MODEL_BD = 1000755015, + XR_TYPE_CAMERA_DEVICE_CREATE_INFO_BD = 1000755016, + XR_TYPE_CREATE_CAMERA_DEVICE_COMPLETION_BD = 1000755017, + XR_TYPE_CAMERA_CAPTURE_SESSION_CREATE_INFO_BD = 1000755018, + XR_TYPE_CREATE_CAMERA_CAPTURE_SESSION_COMPLETION_BD = 1000755019, + XR_TYPE_CAMERA_INTRINSICS_BD = 1000755020, + XR_TYPE_CAMERA_EXTRINSICS_BD = 1000755021, + XR_TYPE_CAMERA_CAPTURE_BEGIN_INFO_BD = 1000755022, + XR_TYPE_CAMERA_IMAGE_ACQUIRE_INFO_BD = 1000755023, + XR_TYPE_CAMERA_IMAGE_BD = 1000755024, + XR_TYPE_CAMERA_IMAGE_DATA_RAW_BUFFER_BD = 1000755025, + XR_TYPE_CAMERA_CAPABILITIES_BD = 1000755026, + XR_TYPE_CAMERA_CAPABILITY_TYPES_ENUMERATE_INFO_BD = 1000755027, + XR_TYPE_CAMERA_CAPABILITY_TYPES_BD = 1000755028, + XR_TYPE_CAMERA_PROPERTY_TYPES_ENUMERATE_INFO_BD = 1000755029, + XR_TYPE_CAMERA_PROPERTY_TYPES_BD = 1000755030, + XR_TYPE_AVAILABLE_CAMERA_BD = 1000755031, + XR_TYPE_SPATIAL_BOUNDS_SPHEREF_ANDROID = 1000761000, + XR_TYPE_SPATIAL_BOUNDS_BOXF_ANDROID = 1000761001, + XR_TYPE_SPATIAL_BOUNDS_FRUSTUMF_ANDROID = 1000761002, + XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ANCHOR_EXT = 1000762000, + XR_TYPE_SPATIAL_COMPONENT_ANCHOR_LIST_EXT = 1000762001, + XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_EXT = 1000762002, + XR_TYPE_SPATIAL_PERSISTENCE_CONTEXT_CREATE_INFO_EXT = 1000763000, + XR_TYPE_CREATE_SPATIAL_PERSISTENCE_CONTEXT_COMPLETION_EXT = 1000763001, + XR_TYPE_SPATIAL_CONTEXT_PERSISTENCE_CONFIG_EXT = 1000763002, + XR_TYPE_SPATIAL_DISCOVERY_PERSISTENCE_UUID_FILTER_EXT = 1000763003, + XR_TYPE_SPATIAL_COMPONENT_PERSISTENCE_LIST_EXT = 1000763004, + XR_TYPE_HAPTIC_PARAMETRIC_VIBRATION_EXT = 1000775000, + XR_TYPE_HAPTIC_PARAMETRIC_PROPERTIES_EXT = 1000775001, + XR_TYPE_SYSTEM_HAPTIC_PARAMETRIC_PROPERTIES_EXT = 1000775002, + XR_TYPE_COLOR_SPACES_ENUMERATE_INFO_SONY = 1000776000, + XR_TYPE_SWAPCHAIN_CREATE_INFO_COLOR_SPACE_SONY = 1000776001, + XR_TYPE_HDR_METADATA_SONY = 1000777000, + XR_TYPE_SPATIAL_ENTITY_PERSIST_INFO_EXT = 1000781000, + XR_TYPE_PERSIST_SPATIAL_ENTITY_COMPLETION_EXT = 1000781001, + XR_TYPE_SPATIAL_ENTITY_UNPERSIST_INFO_EXT = 1000781002, + XR_TYPE_UNPERSIST_SPATIAL_ENTITY_COMPLETION_EXT = 1000781003, + XR_TYPE_SPATIAL_REFERENCE_IMAGE_EXT = 1000782000, + XR_TYPE_SPATIAL_IMAGE_STATIC_OPTIMIZATION_EXT = 1000782001, + XR_TYPE_SPATIAL_IMAGE_SIZE_EXT = 1000782002, + XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_IMAGE_TRACKING_EXT = 1000782003, + XR_TYPE_SPATIAL_IMAGE_TRACKING_DATABASE_CREATE_INFO_EXT = 1000782004, + XR_TYPE_SPATIAL_COMPONENT_IMAGE_2D_LIST_EXT = 1000782005, + XR_TYPE_CREATE_SPATIAL_IMAGE_TRACKING_DATABASE_COMPLETION_EXT = 1000782006, + XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_OBJECT_TRACKING_ANDROID = 1000785000, + XR_TYPE_SPATIAL_COMPONENT_OBJECT_SEMANTIC_LABEL_LIST_ANDROID = 1000785001, + XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_DEPTH_RAYCAST_ANDROID = 1000786000, + XR_TYPE_SPATIAL_RAYCAST_INFO_ANDROID = 1000786001, + XR_TYPE_SPATIAL_COMPONENT_RAYCAST_RESULT_LIST_ANDROID = 1000786002, + XR_TYPE_SPATIAL_RAYCAST_SNAPSHOT_CREATE_INFO_ANDROID = 1000786003, + XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_API_KEY_ANDROID = 1000787000, + XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_TOKEN_ANDROID = 1000787001, + XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_KEYLESS_ANDROID = 1000787002, + XR_TYPE_GOOGLE_CLOUD_AUTH_ERROR_RESULT_ANDROID = 1000787003, + XR_TYPE_SYSTEM_GEOSPATIAL_PROPERTIES_ANDROID = 1000789000, + XR_TYPE_GEOSPATIAL_TRACKER_CREATE_INFO_ANDROID = 1000789001, + XR_TYPE_EVENT_DATA_GEOSPATIAL_TRACKER_STATE_CHANGED_ANDROID = 1000789002, + XR_TYPE_GEOSPATIAL_POSE_FROM_POSE_LOCATE_INFO_ANDROID = 1000789003, + XR_TYPE_GEOSPATIAL_POSE_RESULT_ANDROID = 1000789004, + XR_TYPE_GEOSPATIAL_POSE_LOCATE_INFO_ANDROID = 1000789005, + XR_TYPE_VPS_AVAILABILITY_CHECK_COMPLETION_ANDROID = 1000789006, + XR_TYPE_SPATIAL_ANCHOR_PARENT_ANDROID = 1000790000, + XR_TYPE_SPATIAL_DISCOVERY_UNIQUE_ENTITIES_FILTER_ANDROID = 1000791001, + XR_TYPE_SPATIAL_COMPONENT_SUBSUMED_BY_LIST_ANDROID = 1000791002, + XR_TYPE_SPATIAL_ANCHOR_SPACE_FROM_ID_CREATE_INFO_ANDROID = 1000795000, + XR_TYPE_GEOSPATIAL_ANCHOR_CREATE_INFO_ANDROID = 1000797000, + XR_TYPE_SURFACE_ANCHOR_CREATE_INFO_ANDROID = 1000797001, + XR_TYPE_SURFACE_ANCHOR_CREATE_COMPLETION_ANDROID = 1000797002, + XR_TYPE_SYSTEM_GEOSPATIAL_ANCHOR_PROPERTIES_ANDROID = 1000797003, + XR_TYPE_GEOSPATIAL_TRACKER_ANCHOR_TRACKING_INFO_ANDROID = 1000797004, + XR_TYPE_SPATIAL_CONTAINER_CREATE_INFO_EXT = 1000810000, + XR_TYPE_SPATIAL_CONTAINER_SPACE_CREATE_INFO_EXT = 1000810001, + XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_CLOSED_EXT = 1000810003, + XR_TYPE_SYSTEM_SPATIAL_CONTAINER_PROPERTIES_EXT = 1000810004, + XR_TYPE_SPATIAL_CONTAINER_BOUNDS_EXT = 1000810005, + XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_BOUNDS_CHANGED_EXT = 1000810006, + XR_TYPE_SPATIAL_CONTAINER_BOUNDS_GET_INFO_EXT = 1000810007, + XR_TYPE_SPATIAL_CONTAINER_STATE_GET_INFO_EXT = 1000810008, + XR_TYPE_SPATIAL_CONTAINER_VISIBLE_REQUEST_INFO_EXT = 1000810009, + XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_VISIBLE_CHANGED_EXT = 1000810010, + XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_VISIBLE_REQUEST_DENIED_EXT = 1000810011, + XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_INTERACTABLE_CHANGED_EXT = 1000810012, + XR_TYPE_SPATIAL_CONTAINER_BOUNDS_MODE_REQUEST_INFO_EXT = 1000810013, + XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_BOUNDS_MODE_REQUEST_DENIED_EXT = 1000810014, + XR_TYPE_SPATIAL_CONTAINER_STATE_EXT = 1000810015, + XR_TYPE_SESSION_CREATE_INFO_SPATIAL_CONTAINERS_EXT = 1000810016, + XR_TYPE_SPATIAL_CONTAINER_VIEW_LOCATE_INFO_EXT = 1000813000, + XR_TYPE_SPATIAL_CONTAINER_VIEWS_LOCATE_INFO_EXT = 1000813001, + XR_TYPE_SPATIAL_CONTAINER_VIEW_STATE_EXT = 1000813002, + XR_TYPE_SPATIAL_CONTAINER_LAYER_EXT = 1000813003, + XR_TYPE_SPATIAL_CONTAINER_LAYER_FRAME_END_INFO_EXT = 1000813004, + XR_TYPE_SPATIAL_CONTAINER_BEGIN_INFO_EXT = 1000813005, + XR_TYPE_SPATIAL_CONTAINER_COMPOSITION_LAYER_VIEW_CONFIGURATION_EXT = 1000813006, + XR_TYPE_SPATIAL_CONTAINER_END_INFO_EXT = 1000813007, + XR_TYPE_SPATIAL_CONTAINER_LAYER_VOLUME_CLIPPING_EXT = 1000813008, + XR_TYPE_BATTERY_STATE_DISPLAY_EXT = 1000836000, + XR_TYPE_LOADER_INIT_INFO_PROPERTIES_EXT = 1000838000, + XR_TYPE_EVENT_DATA_VIEW_CONFIGURATION_VIEWS_CHANGED_EXT = 1000839000, + 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_TYPE_DEVICE_PCM_SAMPLE_RATE_GET_INFO_FB = XR_TYPE_DEVICE_PCM_SAMPLE_RATE_STATE_FB, + XR_TYPE_SPACES_LOCATE_INFO_KHR = XR_TYPE_SPACES_LOCATE_INFO, + XR_TYPE_SPACE_LOCATIONS_KHR = XR_TYPE_SPACE_LOCATIONS, + XR_TYPE_SPACE_VELOCITIES_KHR = XR_TYPE_SPACE_VELOCITIES, + 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 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 XrViewConfigurationType { + XR_VIEW_CONFIGURATION_TYPE_PRIMARY_MONO = 1, + XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO = 2, + XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO_WITH_FOVEATED_INSET = 1000037000, + XR_VIEW_CONFIGURATION_TYPE_SECONDARY_MONO_FIRST_PERSON_OBSERVER_MSFT = 1000054000, + XR_VIEW_CONFIGURATION_TYPE_PRIMARY_QUAD_VARJO = XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO_WITH_FOVEATED_INSET, + XR_VIEW_CONFIGURATION_TYPE_MAX_ENUM = 0x7FFFFFFF +} XrViewConfigurationType; + +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_LOCAL_FLOOR = 1000426000, + XR_REFERENCE_SPACE_TYPE_UNBOUNDED_MSFT = 1000038000, + XR_REFERENCE_SPACE_TYPE_COMBINED_EYE_VARJO = 1000121000, + XR_REFERENCE_SPACE_TYPE_LOCALIZATION_MAP_ML = 1000139000, + XR_REFERENCE_SPACE_TYPE_UNBOUNDED_ANDROID = 1000467000, + XR_REFERENCE_SPACE_TYPE_STATIONARY_EXT = 1000742000, + XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR_EXT = XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR, + XR_REFERENCE_SPACE_TYPE_MAX_ENUM = 0x7FFFFFFF +} XrReferenceSpaceType; + +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 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 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_SPATIAL_GRAPH_NODE_BINDING_MSFT = 1000049000, + XR_OBJECT_TYPE_HAND_TRACKER_EXT = 1000051000, + XR_OBJECT_TYPE_BODY_TRACKER_FB = 1000076000, + 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_MARKER_DETECTOR_ML = 1000138000, + XR_OBJECT_TYPE_EXPORTED_LOCALIZATION_MAP_ML = 1000139000, + XR_OBJECT_TYPE_SPATIAL_ANCHORS_STORAGE_ML = 1000141000, + XR_OBJECT_TYPE_SPATIAL_ANCHOR_STORE_CONNECTION_MSFT = 1000142000, + XR_OBJECT_TYPE_FACE_TRACKER_FB = 1000201000, + XR_OBJECT_TYPE_EYE_TRACKER_FB = 1000202000, + XR_OBJECT_TYPE_VIRTUAL_KEYBOARD_META = 1000219000, + XR_OBJECT_TYPE_SPACE_USER_FB = 1000241000, + XR_OBJECT_TYPE_PASSTHROUGH_COLOR_LUT_META = 1000266000, + XR_OBJECT_TYPE_FACE_TRACKER2_FB = 1000287012, + XR_OBJECT_TYPE_ENVIRONMENT_DEPTH_PROVIDER_META = 1000291000, + XR_OBJECT_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_META = 1000291001, + XR_OBJECT_TYPE_RENDER_MODEL_EXT = 1000300000, + XR_OBJECT_TYPE_RENDER_MODEL_ASSET_EXT = 1000300001, + XR_OBJECT_TYPE_PASSTHROUGH_HTC = 1000317000, + XR_OBJECT_TYPE_BODY_TRACKER_HTC = 1000320000, + XR_OBJECT_TYPE_BODY_TRACKER_BD = 1000385000, + XR_OBJECT_TYPE_FACE_TRACKER_BD = 1000386000, + XR_OBJECT_TYPE_SENSE_DATA_PROVIDER_BD = 1000389000, + XR_OBJECT_TYPE_SENSE_DATA_SNAPSHOT_BD = 1000389001, + XR_OBJECT_TYPE_ANCHOR_BD = 1000389002, + XR_OBJECT_TYPE_SPATIAL_AUDIO_RENDERER_BD = 1000409000, + XR_OBJECT_TYPE_SOUND_FIELD_BD = 1000409001, + XR_OBJECT_TYPE_SOUND_OBJECT_BD = 1000409002, + XR_OBJECT_TYPE_SOUND_OBSTACLE_BD = 1000409003, + XR_OBJECT_TYPE_SOUND_OBSTACLE_MATERIAL_BD = 1000409004, + XR_OBJECT_TYPE_PLANE_DETECTOR_EXT = 1000429000, + XR_OBJECT_TYPE_TRACKABLE_TRACKER_ANDROID = 1000455001, + XR_OBJECT_TYPE_EYE_TRACKER_ANDROID = 1000456000, + XR_OBJECT_TYPE_DEVICE_ANCHOR_PERSISTENCE_ANDROID = 1000457000, + XR_OBJECT_TYPE_FACE_TRACKER_ANDROID = 1000458000, + XR_OBJECT_TYPE_PASSTHROUGH_LAYER_ANDROID = 1000462000, + XR_OBJECT_TYPE_WORLD_MESH_DETECTOR_ML = 1000474000, + XR_OBJECT_TYPE_FACIAL_EXPRESSION_CLIENT_ML = 1000482000, + XR_OBJECT_TYPE_ENVIRONMENT_RAYCASTER_META = 1000592000, + XR_OBJECT_TYPE_LIGHT_ESTIMATOR_ANDROID = 1000700000, + XR_OBJECT_TYPE_TRACKABLE_IMAGE_DATABASE_ANDROID = 1000709000, + XR_OBJECT_TYPE_SCENE_MESHING_TRACKER_ANDROID = 1000718000, + XR_OBJECT_TYPE_SCENE_MESH_SNAPSHOT_ANDROID = 1000718001, + XR_OBJECT_TYPE_SPATIAL_ENTITY_EXT = 1000740000, + XR_OBJECT_TYPE_SPATIAL_CONTEXT_EXT = 1000740001, + XR_OBJECT_TYPE_SPATIAL_SNAPSHOT_EXT = 1000740002, + XR_OBJECT_TYPE_CAMERA_DEVICE_BD = 1000755000, + XR_OBJECT_TYPE_CAMERA_CAPTURE_SESSION_BD = 1000755001, + XR_OBJECT_TYPE_SPATIAL_PERSISTENCE_CONTEXT_EXT = 1000763000, + XR_OBJECT_TYPE_SPATIAL_IMAGE_TRACKING_DATABASE_EXT = 1000782000, + XR_OBJECT_TYPE_GEOSPATIAL_TRACKER_ANDROID = 1000789000, + XR_OBJECT_TYPE_SPATIAL_CONTAINER_EXT = 1000810000, + XR_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF +} XrObjectType; +typedef XrFlags64 XrInstanceCreateFlags; + +// Flag bits for XrInstanceCreateFlags + +typedef XrFlags64 XrSessionCreateFlags; + +// Flag bits for XrSessionCreateFlags + +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 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 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 +// XR_COMPOSITION_LAYER_CORRECT_CHROMATIC_ABERRATION_BIT is deprecated and should not be used +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; +static const XrCompositionLayerFlags XR_COMPOSITION_LAYER_INVERTED_ALPHA_BIT_EXT = 0x00000008; + +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 XrQuaternionf { + float x; + float y; + float z; + float w; +} XrQuaternionf; + +typedef struct XrVector3f { + float x; + float y; + float z; +} XrVector3f; + +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 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; + +// XrSpaceVelocity extends XrSpaceLocation +typedef struct XrSpaceVelocity { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrSpaceVelocityFlags velocityFlags; + XrVector3f linearVelocity; + XrVector3f angularVelocity; +} XrSpaceVelocity; + +typedef struct XrExtent2Df { + float width; + float height; +} XrExtent2Df; + +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 XrFrameState { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrTime predictedDisplayTime; + XrDuration predictedDisplayPeriod; + XrBool32 shouldRender; +} XrFrameState; + +typedef struct XrFrameWaitInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrFrameWaitInfo; + +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 XrViewState { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrViewStateFlags viewStateFlags; +} XrViewState; + +typedef struct XrViewLocateInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrViewConfigurationType viewConfigurationType; + XrTime displayTime; + XrSpace space; +} XrViewLocateInfo; + +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 XR_MAY_ALIAS XrHapticBaseHeader { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrHapticBaseHeader; + +typedef struct XrHapticActionInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAction action; + XrPath subactionPath; +} XrHapticActionInfo; + +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 */ + + +// XR_VERSION_1_1 is a preprocessor guard. Do not pass it to API calls. +#define XR_VERSION_1_1 1 +// OpenXR 1.1 version number +#define XR_API_VERSION_1_1 XR_MAKE_VERSION(1, 1, XR_VERSION_PATCH(XR_CURRENT_API_VERSION)) + +#define XR_UUID_SIZE 16 +typedef struct XrColor3f { + float r; + float g; + float b; +} XrColor3f; + +typedef struct XrExtent3Df { + float width; + float height; + float depth; +} XrExtent3Df; + +typedef struct XrSpheref { + XrPosef center; + float radius; +} XrSpheref; + +typedef struct XrBoxf { + XrPosef center; + XrExtent3Df extents; +} XrBoxf; + +typedef struct XrFrustumf { + XrPosef pose; + XrFovf fov; + float nearZ; + float farZ; +} XrFrustumf; + +typedef struct XrUuid { + uint8_t data[XR_UUID_SIZE]; +} XrUuid; + +typedef struct XrSpacesLocateInfo { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace baseSpace; + XrTime time; + uint32_t spaceCount; + const XrSpace* spaces; +} XrSpacesLocateInfo; + +typedef struct XrSpaceLocationData { + XrSpaceLocationFlags locationFlags; + XrPosef pose; +} XrSpaceLocationData; + +typedef struct XrSpaceLocations { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t locationCount; + XrSpaceLocationData* locations; +} XrSpaceLocations; + +typedef struct XrSpaceVelocityData { + XrSpaceVelocityFlags velocityFlags; + XrVector3f linearVelocity; + XrVector3f angularVelocity; +} XrSpaceVelocityData; + +// XrSpaceVelocities extends XrSpaceLocations +typedef struct XrSpaceVelocities { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t velocityCount; + XrSpaceVelocityData* velocities; +} XrSpaceVelocities; + +typedef XrResult (XRAPI_PTR *PFN_xrLocateSpaces)(XrSession session, const XrSpacesLocateInfo* locateInfo, XrSpaceLocations* spaceLocations); + +#ifndef XR_NO_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrLocateSpaces( + XrSession session, + const XrSpacesLocateInfo* locateInfo, + XrSpaceLocations* spaceLocations); +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_KHR_composition_layer_cube is a preprocessor guard. Do not pass it to API calls. +#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; + + + +// XR_KHR_composition_layer_depth is a preprocessor guard. Do not pass it to API calls. +#define XR_KHR_composition_layer_depth 1 +#define XR_KHR_composition_layer_depth_SPEC_VERSION 6 +#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; + + + +// XR_KHR_composition_layer_cylinder is a preprocessor guard. Do not pass it to API calls. +#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; + + + +// XR_KHR_composition_layer_equirect is a preprocessor guard. Do not pass it to API calls. +#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; + + + +// XR_KHR_visibility_mask is a preprocessor guard. Do not pass it to API calls. +#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 */ + + +// XR_KHR_composition_layer_color_scale_bias is a preprocessor guard. Do not pass it to API calls. +#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; + + + +// XR_KHR_loader_init is a preprocessor guard. Do not pass it to API calls. +#define XR_KHR_loader_init 1 +#define XR_KHR_loader_init_SPEC_VERSION 2 +#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 */ + + +// XR_KHR_composition_layer_equirect2 is a preprocessor guard. Do not pass it to API calls. +#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; + + + +// XR_KHR_binding_modification is a preprocessor guard. Do not pass it to API calls. +#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; + + + +// XR_KHR_extended_struct_name_lengths is a preprocessor guard. Do not pass it to API calls. +#define XR_KHR_extended_struct_name_lengths 1 +#define XR_KHR_extended_struct_name_lengths_SPEC_VERSION 2 +#define XR_KHR_EXTENDED_STRUCT_NAME_LENGTHS_EXTENSION_NAME "XR_KHR_extended_struct_name_lengths" +#define XR_MAX_STRUCTURE_NAME_SIZE_EXTENDED_KHR 256 +typedef XrResult (XRAPI_PTR *PFN_xrStructureTypeToString2KHR)(XrInstance instance, XrStructureType value, char buffer[XR_MAX_STRUCTURE_NAME_SIZE_EXTENDED_KHR]); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrStructureTypeToString2KHR( + XrInstance instance, + XrStructureType value, + char buffer[XR_MAX_STRUCTURE_NAME_SIZE_EXTENDED_KHR]); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_KHR_swapchain_usage_input_attachment_bit is a preprocessor guard. Do not pass it to API calls. +#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" + + +// XR_KHR_locate_spaces is a preprocessor guard. Do not pass it to API calls. +#define XR_KHR_locate_spaces 1 +#define XR_KHR_locate_spaces_SPEC_VERSION 1 +#define XR_KHR_LOCATE_SPACES_EXTENSION_NAME "XR_KHR_locate_spaces" +typedef XrSpacesLocateInfo XrSpacesLocateInfoKHR; + +typedef XrSpaceLocationData XrSpaceLocationDataKHR; + +typedef XrSpaceLocations XrSpaceLocationsKHR; + +typedef XrSpaceVelocityData XrSpaceVelocityDataKHR; + +typedef XrSpaceVelocities XrSpaceVelocitiesKHR; + +typedef XrResult (XRAPI_PTR *PFN_xrLocateSpacesKHR)(XrSession session, const XrSpacesLocateInfo* locateInfo, XrSpaceLocations* spaceLocations); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrLocateSpacesKHR( + XrSession session, + const XrSpacesLocateInfo* locateInfo, + XrSpaceLocations* spaceLocations); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_KHR_maintenance1 is a preprocessor guard. Do not pass it to API calls. +#define XR_KHR_maintenance1 1 +#define XR_KHR_maintenance1_SPEC_VERSION 1 +#define XR_KHR_MAINTENANCE1_EXTENSION_NAME "XR_KHR_maintenance1" +typedef XrColor3f XrColor3fKHR; + +typedef XrExtent3Df XrExtent3DfKHR; + +typedef XrSpheref XrSpherefKHR; + +typedef XrBoxf XrBoxfKHR; + +typedef XrFrustumf XrFrustumfKHR; + + + +// XR_KHR_generic_controller is a preprocessor guard. Do not pass it to API calls. +#define XR_KHR_generic_controller 1 +#define XR_KHR_generic_controller_SPEC_VERSION 1 +#define XR_KHR_GENERIC_CONTROLLER_EXTENSION_NAME "XR_KHR_generic_controller" + + +// XR_KHR_extended_result_name_lengths is a preprocessor guard. Do not pass it to API calls. +#define XR_KHR_extended_result_name_lengths 1 +#define XR_KHR_extended_result_name_lengths_SPEC_VERSION 1 +#define XR_KHR_EXTENDED_RESULT_NAME_LENGTHS_EXTENSION_NAME "XR_KHR_extended_result_name_lengths" +#define XR_MAX_RESULT_STRING_SIZE_EXTENDED_KHR 256 +typedef XrResult (XRAPI_PTR *PFN_xrResultToString2KHR)(XrInstance instance, XrResult value, char buffer[XR_MAX_RESULT_STRING_SIZE_EXTENDED_KHR]); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrResultToString2KHR( + XrInstance instance, + XrResult value, + char buffer[XR_MAX_RESULT_STRING_SIZE_EXTENDED_KHR]); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_EXT_performance_settings is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_performance_settings 1 +#define XR_EXT_performance_settings_SPEC_VERSION 4 +#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 */ + + +// XR_EXT_thermal_query is a preprocessor guard. Do not pass it to API calls. +#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 */ + + +// XR_EXT_debug_utils is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_debug_utils 1 +XR_DEFINE_HANDLE(XrDebugUtilsMessengerEXT) +#define XR_EXT_debug_utils_SPEC_VERSION 5 +#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 */ + + +// XR_EXT_eye_gaze_interaction is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_eye_gaze_interaction 1 +#define XR_EXT_eye_gaze_interaction_SPEC_VERSION 2 +#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; + + + +// XR_EXTX_overlay is a preprocessor guard. Do not pass it to API calls. +#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; + + + +// XR_VARJO_quad_views is a preprocessor guard. Do not pass it to API calls. +#define XR_VARJO_quad_views 1 +#define XR_VARJO_quad_views_SPEC_VERSION 2 +#define XR_VARJO_QUAD_VIEWS_EXTENSION_NAME "XR_VARJO_quad_views" + + +// XR_MSFT_unbounded_reference_space is a preprocessor guard. Do not pass it to API calls. +#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" + + +// XR_MSFT_spatial_anchor is a preprocessor guard. Do not pass it to API calls. +#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 */ + + +// XR_FB_composition_layer_image_layout is a preprocessor guard. Do not pass it to API calls. +#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; + + + +// XR_FB_composition_layer_alpha_blend is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_composition_layer_alpha_blend 1 +#define XR_FB_composition_layer_alpha_blend_SPEC_VERSION 3 +#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; +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; + +// XrCompositionLayerAlphaBlendFB extends XrCompositionLayerBaseHeader +typedef struct XrCompositionLayerAlphaBlendFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBlendFactorFB srcFactorColor; + XrBlendFactorFB dstFactorColor; + XrBlendFactorFB srcFactorAlpha; + XrBlendFactorFB dstFactorAlpha; +} XrCompositionLayerAlphaBlendFB; + + + +// XR_MND_headless is a preprocessor guard. Do not pass it to API calls. +#define XR_MND_headless 1 +#define XR_MND_headless_SPEC_VERSION 3 +#define XR_MND_HEADLESS_EXTENSION_NAME "XR_MND_headless" + + +// XR_OCULUS_android_session_state_enable is a preprocessor guard. Do not pass it to API calls. +#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" + + +// XR_EXT_view_configuration_depth_range is a preprocessor guard. Do not pass it to API calls. +#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; + + + +// XR_EXT_conformance_automation is a preprocessor guard. Do not pass it to API calls. +#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 */ + + +// XR_MSFT_spatial_graph_bridge is a preprocessor guard. Do not pass it to API calls. +#define XR_MSFT_spatial_graph_bridge 1 +XR_DEFINE_HANDLE(XrSpatialGraphNodeBindingMSFT) +#define XR_GUID_SIZE_MSFT 16 +#define XR_MSFT_spatial_graph_bridge_SPEC_VERSION 2 +#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[XR_GUID_SIZE_MSFT]; + XrPosef pose; +} XrSpatialGraphNodeSpaceCreateInfoMSFT; + +typedef struct XrSpatialGraphStaticNodeBindingCreateInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace space; + XrPosef poseInSpace; + XrTime time; +} XrSpatialGraphStaticNodeBindingCreateInfoMSFT; + +typedef struct XrSpatialGraphNodeBindingPropertiesGetInfoMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrSpatialGraphNodeBindingPropertiesGetInfoMSFT; + +typedef struct XrSpatialGraphNodeBindingPropertiesMSFT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint8_t nodeId[XR_GUID_SIZE_MSFT]; + XrPosef poseInNodeSpace; +} XrSpatialGraphNodeBindingPropertiesMSFT; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialGraphNodeSpaceMSFT)(XrSession session, const XrSpatialGraphNodeSpaceCreateInfoMSFT* createInfo, XrSpace* space); +typedef XrResult (XRAPI_PTR *PFN_xrTryCreateSpatialGraphStaticNodeBindingMSFT)(XrSession session, const XrSpatialGraphStaticNodeBindingCreateInfoMSFT* createInfo, XrSpatialGraphNodeBindingMSFT* nodeBinding); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialGraphNodeBindingMSFT)(XrSpatialGraphNodeBindingMSFT nodeBinding); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialGraphNodeBindingPropertiesMSFT)(XrSpatialGraphNodeBindingMSFT nodeBinding, const XrSpatialGraphNodeBindingPropertiesGetInfoMSFT* getInfo, XrSpatialGraphNodeBindingPropertiesMSFT* properties); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialGraphNodeSpaceMSFT( + XrSession session, + const XrSpatialGraphNodeSpaceCreateInfoMSFT* createInfo, + XrSpace* space); + +XRAPI_ATTR XrResult XRAPI_CALL xrTryCreateSpatialGraphStaticNodeBindingMSFT( + XrSession session, + const XrSpatialGraphStaticNodeBindingCreateInfoMSFT* createInfo, + XrSpatialGraphNodeBindingMSFT* nodeBinding); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialGraphNodeBindingMSFT( + XrSpatialGraphNodeBindingMSFT nodeBinding); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialGraphNodeBindingPropertiesMSFT( + XrSpatialGraphNodeBindingMSFT nodeBinding, + const XrSpatialGraphNodeBindingPropertiesGetInfoMSFT* getInfo, + XrSpatialGraphNodeBindingPropertiesMSFT* properties); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_MSFT_hand_interaction is a preprocessor guard. Do not pass it to API calls. +#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" + + +// XR_EXT_hand_tracking is a preprocessor guard. Do not pass it to API calls. +#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_HAND_WITH_FOREARM_ULTRALEAP = 1000149000, + 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 */ + + +// XR_MSFT_hand_tracking_mesh is a preprocessor guard. Do not pass it to API calls. +#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 */ + + +// XR_MSFT_secondary_view_configuration is a preprocessor guard. Do not pass it to API calls. +#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; + + + +// XR_MSFT_first_person_observer is a preprocessor guard. Do not pass it to API calls. +#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" + + +// XR_MSFT_controller_model is a preprocessor guard. Do not pass it to API calls. +#define XR_MSFT_controller_model 1 + +#define XR_NULL_CONTROLLER_MODEL_KEY_MSFT 0 + +XR_DEFINE_ATOM(XrControllerModelKeyMSFT) +#define XR_MAX_CONTROLLER_MODEL_NODE_NAME_SIZE_MSFT 64 +#define XR_MSFT_controller_model_SPEC_VERSION 2 +#define XR_MSFT_CONTROLLER_MODEL_EXTENSION_NAME "XR_MSFT_controller_model" +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 */ + + +// XR_EXT_win32_appcontainer_compatible is a preprocessor guard. Do not pass it to API calls. +#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" + + +// XR_EPIC_view_configuration_fov is a preprocessor guard. Do not pass it to API calls. +#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; + + + +// XR_MSFT_composition_layer_reprojection is a preprocessor guard. Do not pass it to API calls. +#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 */ + + +// XR_HUAWEI_controller_interaction is a preprocessor guard. Do not pass it to API calls. +#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" + + +// XR_FB_swapchain_update_state is a preprocessor guard. Do not pass it to API calls. +#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 */ + + +// XR_FB_composition_layer_secure_content is a preprocessor guard. Do not pass it to API calls. +#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" +// XrCompositionLayerSecureContentFB extends XrCompositionLayerBaseHeader +typedef struct XrCompositionLayerSecureContentFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCompositionLayerSecureContentFlagsFB flags; +} XrCompositionLayerSecureContentFB; + + + +// XR_FB_body_tracking is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_body_tracking 1 +XR_DEFINE_HANDLE(XrBodyTrackerFB) +#define XR_FB_body_tracking_SPEC_VERSION 1 +#define XR_FB_BODY_TRACKING_EXTENSION_NAME "XR_FB_body_tracking" + +typedef enum XrBodyJointFB { + XR_BODY_JOINT_ROOT_FB = 0, + XR_BODY_JOINT_HIPS_FB = 1, + XR_BODY_JOINT_SPINE_LOWER_FB = 2, + XR_BODY_JOINT_SPINE_MIDDLE_FB = 3, + XR_BODY_JOINT_SPINE_UPPER_FB = 4, + XR_BODY_JOINT_CHEST_FB = 5, + XR_BODY_JOINT_NECK_FB = 6, + XR_BODY_JOINT_HEAD_FB = 7, + XR_BODY_JOINT_LEFT_SHOULDER_FB = 8, + XR_BODY_JOINT_LEFT_SCAPULA_FB = 9, + XR_BODY_JOINT_LEFT_ARM_UPPER_FB = 10, + XR_BODY_JOINT_LEFT_ARM_LOWER_FB = 11, + XR_BODY_JOINT_LEFT_HAND_WRIST_TWIST_FB = 12, + XR_BODY_JOINT_RIGHT_SHOULDER_FB = 13, + XR_BODY_JOINT_RIGHT_SCAPULA_FB = 14, + XR_BODY_JOINT_RIGHT_ARM_UPPER_FB = 15, + XR_BODY_JOINT_RIGHT_ARM_LOWER_FB = 16, + XR_BODY_JOINT_RIGHT_HAND_WRIST_TWIST_FB = 17, + XR_BODY_JOINT_LEFT_HAND_PALM_FB = 18, + XR_BODY_JOINT_LEFT_HAND_WRIST_FB = 19, + XR_BODY_JOINT_LEFT_HAND_THUMB_METACARPAL_FB = 20, + XR_BODY_JOINT_LEFT_HAND_THUMB_PROXIMAL_FB = 21, + XR_BODY_JOINT_LEFT_HAND_THUMB_DISTAL_FB = 22, + XR_BODY_JOINT_LEFT_HAND_THUMB_TIP_FB = 23, + XR_BODY_JOINT_LEFT_HAND_INDEX_METACARPAL_FB = 24, + XR_BODY_JOINT_LEFT_HAND_INDEX_PROXIMAL_FB = 25, + XR_BODY_JOINT_LEFT_HAND_INDEX_INTERMEDIATE_FB = 26, + XR_BODY_JOINT_LEFT_HAND_INDEX_DISTAL_FB = 27, + XR_BODY_JOINT_LEFT_HAND_INDEX_TIP_FB = 28, + XR_BODY_JOINT_LEFT_HAND_MIDDLE_METACARPAL_FB = 29, + XR_BODY_JOINT_LEFT_HAND_MIDDLE_PROXIMAL_FB = 30, + XR_BODY_JOINT_LEFT_HAND_MIDDLE_INTERMEDIATE_FB = 31, + XR_BODY_JOINT_LEFT_HAND_MIDDLE_DISTAL_FB = 32, + XR_BODY_JOINT_LEFT_HAND_MIDDLE_TIP_FB = 33, + XR_BODY_JOINT_LEFT_HAND_RING_METACARPAL_FB = 34, + XR_BODY_JOINT_LEFT_HAND_RING_PROXIMAL_FB = 35, + XR_BODY_JOINT_LEFT_HAND_RING_INTERMEDIATE_FB = 36, + XR_BODY_JOINT_LEFT_HAND_RING_DISTAL_FB = 37, + XR_BODY_JOINT_LEFT_HAND_RING_TIP_FB = 38, + XR_BODY_JOINT_LEFT_HAND_LITTLE_METACARPAL_FB = 39, + XR_BODY_JOINT_LEFT_HAND_LITTLE_PROXIMAL_FB = 40, + XR_BODY_JOINT_LEFT_HAND_LITTLE_INTERMEDIATE_FB = 41, + XR_BODY_JOINT_LEFT_HAND_LITTLE_DISTAL_FB = 42, + XR_BODY_JOINT_LEFT_HAND_LITTLE_TIP_FB = 43, + XR_BODY_JOINT_RIGHT_HAND_PALM_FB = 44, + XR_BODY_JOINT_RIGHT_HAND_WRIST_FB = 45, + XR_BODY_JOINT_RIGHT_HAND_THUMB_METACARPAL_FB = 46, + XR_BODY_JOINT_RIGHT_HAND_THUMB_PROXIMAL_FB = 47, + XR_BODY_JOINT_RIGHT_HAND_THUMB_DISTAL_FB = 48, + XR_BODY_JOINT_RIGHT_HAND_THUMB_TIP_FB = 49, + XR_BODY_JOINT_RIGHT_HAND_INDEX_METACARPAL_FB = 50, + XR_BODY_JOINT_RIGHT_HAND_INDEX_PROXIMAL_FB = 51, + XR_BODY_JOINT_RIGHT_HAND_INDEX_INTERMEDIATE_FB = 52, + XR_BODY_JOINT_RIGHT_HAND_INDEX_DISTAL_FB = 53, + XR_BODY_JOINT_RIGHT_HAND_INDEX_TIP_FB = 54, + XR_BODY_JOINT_RIGHT_HAND_MIDDLE_METACARPAL_FB = 55, + XR_BODY_JOINT_RIGHT_HAND_MIDDLE_PROXIMAL_FB = 56, + XR_BODY_JOINT_RIGHT_HAND_MIDDLE_INTERMEDIATE_FB = 57, + XR_BODY_JOINT_RIGHT_HAND_MIDDLE_DISTAL_FB = 58, + XR_BODY_JOINT_RIGHT_HAND_MIDDLE_TIP_FB = 59, + XR_BODY_JOINT_RIGHT_HAND_RING_METACARPAL_FB = 60, + XR_BODY_JOINT_RIGHT_HAND_RING_PROXIMAL_FB = 61, + XR_BODY_JOINT_RIGHT_HAND_RING_INTERMEDIATE_FB = 62, + XR_BODY_JOINT_RIGHT_HAND_RING_DISTAL_FB = 63, + XR_BODY_JOINT_RIGHT_HAND_RING_TIP_FB = 64, + XR_BODY_JOINT_RIGHT_HAND_LITTLE_METACARPAL_FB = 65, + XR_BODY_JOINT_RIGHT_HAND_LITTLE_PROXIMAL_FB = 66, + XR_BODY_JOINT_RIGHT_HAND_LITTLE_INTERMEDIATE_FB = 67, + XR_BODY_JOINT_RIGHT_HAND_LITTLE_DISTAL_FB = 68, + XR_BODY_JOINT_RIGHT_HAND_LITTLE_TIP_FB = 69, + XR_BODY_JOINT_COUNT_FB = 70, + XR_BODY_JOINT_NONE_FB = -1, + XR_BODY_JOINT_MAX_ENUM_FB = 0x7FFFFFFF +} XrBodyJointFB; + +typedef enum XrBodyJointSetFB { + XR_BODY_JOINT_SET_DEFAULT_FB = 0, + XR_BODY_JOINT_SET_FULL_BODY_META = 1000274000, + XR_BODY_JOINT_SET_MAX_ENUM_FB = 0x7FFFFFFF +} XrBodyJointSetFB; +typedef struct XrBodyJointLocationFB { + XrSpaceLocationFlags locationFlags; + XrPosef pose; +} XrBodyJointLocationFB; + +// XrSystemBodyTrackingPropertiesFB extends XrSystemProperties +typedef struct XrSystemBodyTrackingPropertiesFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsBodyTracking; +} XrSystemBodyTrackingPropertiesFB; + +typedef struct XrBodyTrackerCreateInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBodyJointSetFB bodyJointSet; +} XrBodyTrackerCreateInfoFB; + +typedef struct XrBodySkeletonJointFB { + int32_t joint; + int32_t parentJoint; + XrPosef pose; +} XrBodySkeletonJointFB; + +typedef struct XrBodySkeletonFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t jointCount; + XrBodySkeletonJointFB* joints; +} XrBodySkeletonFB; + +typedef struct XrBodyJointsLocateInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace baseSpace; + XrTime time; +} XrBodyJointsLocateInfoFB; + +typedef struct XrBodyJointLocationsFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 isActive; + float confidence; + uint32_t jointCount; + XrBodyJointLocationFB* jointLocations; + uint32_t skeletonChangedCount; + XrTime time; +} XrBodyJointLocationsFB; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateBodyTrackerFB)(XrSession session, const XrBodyTrackerCreateInfoFB* createInfo, XrBodyTrackerFB* bodyTracker); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyBodyTrackerFB)(XrBodyTrackerFB bodyTracker); +typedef XrResult (XRAPI_PTR *PFN_xrLocateBodyJointsFB)(XrBodyTrackerFB bodyTracker, const XrBodyJointsLocateInfoFB* locateInfo, XrBodyJointLocationsFB* locations); +typedef XrResult (XRAPI_PTR *PFN_xrGetBodySkeletonFB)(XrBodyTrackerFB bodyTracker, XrBodySkeletonFB* skeleton); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateBodyTrackerFB( + XrSession session, + const XrBodyTrackerCreateInfoFB* createInfo, + XrBodyTrackerFB* bodyTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyBodyTrackerFB( + XrBodyTrackerFB bodyTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrLocateBodyJointsFB( + XrBodyTrackerFB bodyTracker, + const XrBodyJointsLocateInfoFB* locateInfo, + XrBodyJointLocationsFB* locations); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetBodySkeletonFB( + XrBodyTrackerFB bodyTracker, + XrBodySkeletonFB* skeleton); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_EXT_dpad_binding is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_dpad_binding 1 +#define XR_EXT_dpad_binding_SPEC_VERSION 1 +#define XR_EXT_DPAD_BINDING_EXTENSION_NAME "XR_EXT_dpad_binding" +typedef struct XrInteractionProfileDpadBindingEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPath binding; + XrActionSet actionSet; + float forceThreshold; + float forceThresholdReleased; + float centerRegion; + float wedgeAngle; + XrBool32 isSticky; + const XrHapticBaseHeader* onHaptic; + const XrHapticBaseHeader* offHaptic; +} XrInteractionProfileDpadBindingEXT; + + + +// XR_VALVE_analog_threshold is a preprocessor guard. Do not pass it to API calls. +#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; + + + +// XR_EXT_hand_joints_motion_range is a preprocessor guard. Do not pass it to API calls. +#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; + + + +// XR_EXT_samsung_odyssey_controller is a preprocessor guard. Do not pass it to API calls. +#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" + + +// XR_EXT_hp_mixed_reality_controller is a preprocessor guard. Do not pass it to API calls. +#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" + + +// XR_MND_swapchain_usage_input_attachment_bit is a preprocessor guard. Do not pass it to API calls. +#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" + + +// XR_MSFT_scene_understanding is a preprocessor guard. Do not pass it to API calls. +#define XR_MSFT_scene_understanding 1 + + XR_DEFINE_HANDLE(XrSceneMSFT) + + + XR_DEFINE_HANDLE(XrSceneObserverMSFT) + +#define XR_MSFT_scene_understanding_SPEC_VERSION 2 +#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_MARKER_MSFT = 1000147000, + 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_MARKER_MSFT = 1000147000, + 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; + +// XrSceneMeshVertexBufferMSFT extends XrSceneMeshBuffersMSFT +typedef struct XrSceneMeshVertexBufferMSFT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t vertexCapacityInput; + uint32_t vertexCountOutput; + XrVector3f* vertices; +} XrSceneMeshVertexBufferMSFT; + +// XrSceneMeshIndicesUint32MSFT extends XrSceneMeshBuffersMSFT +typedef struct XrSceneMeshIndicesUint32MSFT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t indexCapacityInput; + uint32_t indexCountOutput; + uint32_t* indices; +} XrSceneMeshIndicesUint32MSFT; + +// XrSceneMeshIndicesUint16MSFT extends XrSceneMeshBuffersMSFT +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 */ + + +// XR_MSFT_scene_understanding_serialization is a preprocessor guard. Do not pass it to API calls. +#define XR_MSFT_scene_understanding_serialization 1 +#define XR_MSFT_scene_understanding_serialization_SPEC_VERSION 2 +#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 */ + + +// XR_FB_display_refresh_rate is a preprocessor guard. Do not pass it to API calls. +#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 */ + + +// XR_HTC_vive_cosmos_controller_interaction is a preprocessor guard. Do not pass it to API calls. +#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" + + +// XR_HTCX_vive_tracker_interaction is a preprocessor guard. Do not pass it to API calls. +#define XR_HTCX_vive_tracker_interaction 1 +#define XR_HTCX_vive_tracker_interaction_SPEC_VERSION 3 +#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 */ + + +// XR_HTC_facial_tracking is a preprocessor guard. Do not pass it to API calls. +#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 3 +#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_RAISER_RIGHT_HTC = 12, + XR_LIP_EXPRESSION_MOUTH_RAISER_LEFT_HTC = 13, + XR_LIP_EXPRESSION_MOUTH_STRETCHER_RIGHT_HTC = 14, + XR_LIP_EXPRESSION_MOUTH_STRETCHER_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_MOUTH_SMILE_RIGHT_HTC = XR_LIP_EXPRESSION_MOUTH_RAISER_RIGHT_HTC, + XR_LIP_EXPRESSION_MOUTH_SMILE_LEFT_HTC = XR_LIP_EXPRESSION_MOUTH_RAISER_LEFT_HTC, + XR_LIP_EXPRESSION_MOUTH_SAD_RIGHT_HTC = XR_LIP_EXPRESSION_MOUTH_STRETCHER_RIGHT_HTC, + XR_LIP_EXPRESSION_MOUTH_SAD_LEFT_HTC = XR_LIP_EXPRESSION_MOUTH_STRETCHER_LEFT_HTC, + 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 */ + + +// XR_HTC_vive_focus3_controller_interaction is a preprocessor guard. Do not pass it to API calls. +#define XR_HTC_vive_focus3_controller_interaction 1 +#define XR_HTC_vive_focus3_controller_interaction_SPEC_VERSION 2 +#define XR_HTC_VIVE_FOCUS3_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_HTC_vive_focus3_controller_interaction" + + +// XR_HTC_hand_interaction is a preprocessor guard. Do not pass it to API calls. +#define XR_HTC_hand_interaction 1 +#define XR_HTC_hand_interaction_SPEC_VERSION 1 +#define XR_HTC_HAND_INTERACTION_EXTENSION_NAME "XR_HTC_hand_interaction" + + +// XR_HTC_vive_wrist_tracker_interaction is a preprocessor guard. Do not pass it to API calls. +#define XR_HTC_vive_wrist_tracker_interaction 1 +#define XR_HTC_vive_wrist_tracker_interaction_SPEC_VERSION 1 +#define XR_HTC_VIVE_WRIST_TRACKER_INTERACTION_EXTENSION_NAME "XR_HTC_vive_wrist_tracker_interaction" + + +// XR_FB_color_space is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_color_space 1 +#define XR_FB_color_space_SPEC_VERSION 3 +#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 */ + + +// XR_FB_hand_tracking_mesh is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_hand_tracking_mesh 1 +#define XR_FB_hand_tracking_mesh_SPEC_VERSION 3 +#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 XrHandJointLocationsEXT +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 */ + + +// XR_FB_hand_tracking_aim is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_hand_tracking_aim 1 +#define XR_FB_hand_tracking_aim_SPEC_VERSION 2 +#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 XrHandJointLocationsEXT +typedef struct XrHandTrackingAimStateFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrHandTrackingAimFlagsFB status; + XrPosef aimPose; + float pinchStrengthIndex; + float pinchStrengthMiddle; + float pinchStrengthRing; + float pinchStrengthLittle; +} XrHandTrackingAimStateFB; + + + +// XR_FB_hand_tracking_capsules is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_hand_tracking_capsules 1 +#define XR_HAND_TRACKING_CAPSULE_POINT_COUNT_FB 2 +#define XR_HAND_TRACKING_CAPSULE_COUNT_FB 19 +#define XR_FB_hand_tracking_capsules_SPEC_VERSION 3 +#define XR_FB_HAND_TRACKING_CAPSULES_EXTENSION_NAME "XR_FB_hand_tracking_capsules" +#define XR_FB_HAND_TRACKING_CAPSULE_POINT_COUNT XR_HAND_TRACKING_CAPSULE_POINT_COUNT_FB +#define XR_FB_HAND_TRACKING_CAPSULE_COUNT XR_HAND_TRACKING_CAPSULE_COUNT_FB +typedef struct XrHandCapsuleFB { + XrVector3f points[XR_HAND_TRACKING_CAPSULE_POINT_COUNT_FB]; + float radius; + XrHandJointEXT joint; +} XrHandCapsuleFB; + +// XrHandTrackingCapsulesStateFB extends XrHandJointLocationsEXT +typedef struct XrHandTrackingCapsulesStateFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrHandCapsuleFB capsules[XR_HAND_TRACKING_CAPSULE_COUNT_FB]; +} XrHandTrackingCapsulesStateFB; + + + +// XR_FB_spatial_entity is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_spatial_entity 1 +XR_DEFINE_ATOM(XrAsyncRequestIdFB) +#define XR_FB_spatial_entity_SPEC_VERSION 3 +#define XR_FB_SPATIAL_ENTITY_EXTENSION_NAME "XR_FB_spatial_entity" + +typedef enum XrSpaceComponentTypeFB { + XR_SPACE_COMPONENT_TYPE_LOCATABLE_FB = 0, + XR_SPACE_COMPONENT_TYPE_STORABLE_FB = 1, + XR_SPACE_COMPONENT_TYPE_SHARABLE_FB = 2, + XR_SPACE_COMPONENT_TYPE_BOUNDED_2D_FB = 3, + XR_SPACE_COMPONENT_TYPE_BOUNDED_3D_FB = 4, + XR_SPACE_COMPONENT_TYPE_SEMANTIC_LABELS_FB = 5, + XR_SPACE_COMPONENT_TYPE_ROOM_LAYOUT_FB = 6, + XR_SPACE_COMPONENT_TYPE_SPACE_CONTAINER_FB = 7, + XR_SPACE_COMPONENT_TYPE_TRIANGLE_MESH_META = 1000269000, + XR_SPACE_COMPONENT_TYPE_ROOM_MESH_META = 1000553000, + XR_SPACE_COMPONENT_TYPE_MAX_ENUM_FB = 0x7FFFFFFF +} XrSpaceComponentTypeFB; +// XrSystemSpatialEntityPropertiesFB extends XrSystemProperties +typedef struct XrSystemSpatialEntityPropertiesFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 supportsSpatialEntity; +} XrSystemSpatialEntityPropertiesFB; + +typedef struct XrSpatialAnchorCreateInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace space; + XrPosef poseInSpace; + XrTime time; +} XrSpatialAnchorCreateInfoFB; + +typedef struct XrSpaceComponentStatusSetInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpaceComponentTypeFB componentType; + XrBool32 enabled; + XrDuration timeout; +} XrSpaceComponentStatusSetInfoFB; + +typedef struct XrSpaceComponentStatusFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 enabled; + XrBool32 changePending; +} XrSpaceComponentStatusFB; + +typedef XrUuid XrUuidEXT; + +typedef struct XrEventDataSpatialAnchorCreateCompleteFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAsyncRequestIdFB requestId; + XrResult result; + XrSpace space; + XrUuidEXT uuid; +} XrEventDataSpatialAnchorCreateCompleteFB; + +typedef struct XrEventDataSpaceSetStatusCompleteFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAsyncRequestIdFB requestId; + XrResult result; + XrSpace space; + XrUuidEXT uuid; + XrSpaceComponentTypeFB componentType; + XrBool32 enabled; +} XrEventDataSpaceSetStatusCompleteFB; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorFB)(XrSession session, const XrSpatialAnchorCreateInfoFB* info, XrAsyncRequestIdFB* requestId); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceUuidFB)(XrSpace space, XrUuidEXT* uuid); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSpaceSupportedComponentsFB)(XrSpace space, uint32_t componentTypeCapacityInput, uint32_t* componentTypeCountOutput, XrSpaceComponentTypeFB* componentTypes); +typedef XrResult (XRAPI_PTR *PFN_xrSetSpaceComponentStatusFB)(XrSpace space, const XrSpaceComponentStatusSetInfoFB* info, XrAsyncRequestIdFB* requestId); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceComponentStatusFB)(XrSpace space, XrSpaceComponentTypeFB componentType, XrSpaceComponentStatusFB* status); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorFB( + XrSession session, + const XrSpatialAnchorCreateInfoFB* info, + XrAsyncRequestIdFB* requestId); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceUuidFB( + XrSpace space, + XrUuidEXT* uuid); + +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSpaceSupportedComponentsFB( + XrSpace space, + uint32_t componentTypeCapacityInput, + uint32_t* componentTypeCountOutput, + XrSpaceComponentTypeFB* componentTypes); + +XRAPI_ATTR XrResult XRAPI_CALL xrSetSpaceComponentStatusFB( + XrSpace space, + const XrSpaceComponentStatusSetInfoFB* info, + XrAsyncRequestIdFB* requestId); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceComponentStatusFB( + XrSpace space, + XrSpaceComponentTypeFB componentType, + XrSpaceComponentStatusFB* status); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_FB_foveation is a preprocessor guard. Do not pass it to API calls. +#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 */ + + +// XR_FB_foveation_configuration is a preprocessor guard. Do not pass it to API calls. +#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; + + + +// XR_FB_keyboard_tracking is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_keyboard_tracking 1 +#define XR_MAX_KEYBOARD_TRACKING_NAME_SIZE_FB 128 +#define XR_FB_keyboard_tracking_SPEC_VERSION 1 +#define XR_FB_KEYBOARD_TRACKING_EXTENSION_NAME "XR_FB_keyboard_tracking" +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 */ + + +// XR_FB_triangle_mesh is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_triangle_mesh 1 +XR_DEFINE_HANDLE(XrTriangleMeshFB) +#define XR_FB_triangle_mesh_SPEC_VERSION 2 +#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 */ + + +// XR_FB_passthrough is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_passthrough 1 +XR_DEFINE_HANDLE(XrPassthroughFB) +XR_DEFINE_HANDLE(XrPassthroughLayerFB) +XR_DEFINE_HANDLE(XrGeometryInstanceFB) +#define XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB 256 +#define XR_FB_passthrough_SPEC_VERSION 5 +#define XR_FB_PASSTHROUGH_EXTENSION_NAME "XR_FB_passthrough" + +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_TRACKED_KEYBOARD_MASKED_HANDS_FB = 1000203002, + XR_PASSTHROUGH_LAYER_PURPOSE_MAX_ENUM_FB = 0x7FFFFFFF +} XrPassthroughLayerPurposeFB; +typedef XrFlags64 XrPassthroughCapabilityFlagsFB; + +// Flag bits for XrPassthroughCapabilityFlagsFB +static const XrPassthroughCapabilityFlagsFB XR_PASSTHROUGH_CAPABILITY_BIT_FB = 0x00000001; +static const XrPassthroughCapabilityFlagsFB XR_PASSTHROUGH_CAPABILITY_COLOR_BIT_FB = 0x00000002; +static const XrPassthroughCapabilityFlagsFB XR_PASSTHROUGH_CAPABILITY_LAYER_DEPTH_BIT_FB = 0x00000004; + +typedef XrFlags64 XrPassthroughFlagsFB; + +// Flag bits for XrPassthroughFlagsFB +static const XrPassthroughFlagsFB XR_PASSTHROUGH_IS_RUNNING_AT_CREATION_BIT_FB = 0x00000001; +static const XrPassthroughFlagsFB XR_PASSTHROUGH_LAYER_DEPTH_BIT_FB = 0x00000002; + +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; + +// XrSystemPassthroughProperties2FB extends XrSystemProperties +typedef struct XrSystemPassthroughProperties2FB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPassthroughCapabilityFlagsFB capabilities; +} XrSystemPassthroughProperties2FB; + +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; + +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; + +// XrPassthroughColorMapMonoToRgbaFB extends XrPassthroughStyleFB +typedef struct XrPassthroughColorMapMonoToRgbaFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrColor4f textureColorMap[XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB]; +} XrPassthroughColorMapMonoToRgbaFB; + +// XrPassthroughColorMapMonoToMonoFB extends XrPassthroughStyleFB +typedef struct XrPassthroughColorMapMonoToMonoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint8_t textureColorMap[XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB]; +} XrPassthroughColorMapMonoToMonoFB; + +// XrPassthroughBrightnessContrastSaturationFB extends XrPassthroughStyleFB +typedef struct XrPassthroughBrightnessContrastSaturationFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + float brightness; + float contrast; + float saturation; +} XrPassthroughBrightnessContrastSaturationFB; + +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 */ + + +// XR_FB_render_model is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_render_model 1 + +#define XR_NULL_RENDER_MODEL_KEY_FB 0 + +XR_DEFINE_ATOM(XrRenderModelKeyFB) +#define XR_MAX_RENDER_MODEL_NAME_SIZE_FB 64 +#define XR_FB_render_model_SPEC_VERSION 4 +#define XR_FB_RENDER_MODEL_EXTENSION_NAME "XR_FB_render_model" +typedef XrFlags64 XrRenderModelFlagsFB; + +// Flag bits for XrRenderModelFlagsFB +static const XrRenderModelFlagsFB XR_RENDER_MODEL_SUPPORTS_GLTF_2_0_SUBSET_1_BIT_FB = 0x00000001; +static const XrRenderModelFlagsFB XR_RENDER_MODEL_SUPPORTS_GLTF_2_0_SUBSET_2_BIT_FB = 0x00000002; + +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; + +// XrRenderModelCapabilitiesRequestFB extends XrRenderModelPropertiesFB +typedef struct XrRenderModelCapabilitiesRequestFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrRenderModelFlagsFB flags; +} XrRenderModelCapabilitiesRequestFB; + +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 */ + + +// XR_VARJO_foveated_rendering is a preprocessor guard. Do not pass it to API calls. +#define XR_VARJO_foveated_rendering 1 +#define XR_VARJO_foveated_rendering_SPEC_VERSION 3 +#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; + + + +// XR_VARJO_composition_layer_depth_test is a preprocessor guard. Do not pass it to API calls. +#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; + + + +// XR_VARJO_environment_depth_estimation is a preprocessor guard. Do not pass it to API calls. +#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 */ + + +// XR_VARJO_marker_tracking is a preprocessor guard. Do not pass it to API calls. +#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 enable); +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 enable); + +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 */ + + +// XR_VARJO_view_offset is a preprocessor guard. Do not pass it to API calls. +#define XR_VARJO_view_offset 1 +#define XR_VARJO_view_offset_SPEC_VERSION 1 +#define XR_VARJO_VIEW_OFFSET_EXTENSION_NAME "XR_VARJO_view_offset" +typedef XrResult (XRAPI_PTR *PFN_xrSetViewOffsetVARJO)(XrSession session, float offset); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrSetViewOffsetVARJO( + XrSession session, + float offset); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_VARJO_xr4_controller_interaction is a preprocessor guard. Do not pass it to API calls. +#define XR_VARJO_xr4_controller_interaction 1 +#define XR_VARJO_xr4_controller_interaction_SPEC_VERSION 2 +#define XR_VARJO_XR4_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_VARJO_xr4_controller_interaction" + + +// XR_ML_ml2_controller_interaction is a preprocessor guard. Do not pass it to API calls. +#define XR_ML_ml2_controller_interaction 1 +#define XR_ML_ml2_controller_interaction_SPEC_VERSION 1 +#define XR_ML_ML2_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_ML_ml2_controller_interaction" + + +// XR_ML_frame_end_info is a preprocessor guard. Do not pass it to API calls. +#define XR_ML_frame_end_info 1 +#define XR_ML_frame_end_info_SPEC_VERSION 1 +#define XR_ML_FRAME_END_INFO_EXTENSION_NAME "XR_ML_frame_end_info" +typedef XrFlags64 XrFrameEndInfoFlagsML; + +// Flag bits for XrFrameEndInfoFlagsML +static const XrFrameEndInfoFlagsML XR_FRAME_END_INFO_PROTECTED_BIT_ML = 0x00000001; +static const XrFrameEndInfoFlagsML XR_FRAME_END_INFO_VIGNETTE_BIT_ML = 0x00000002; + +// XrFrameEndInfoML extends XrFrameEndInfo +typedef struct XrFrameEndInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + float focusDistance; + XrFrameEndInfoFlagsML flags; +} XrFrameEndInfoML; + + + +// XR_ML_global_dimmer is a preprocessor guard. Do not pass it to API calls. +#define XR_ML_global_dimmer 1 +#define XR_ML_global_dimmer_SPEC_VERSION 1 +#define XR_ML_GLOBAL_DIMMER_EXTENSION_NAME "XR_ML_global_dimmer" +typedef XrFlags64 XrGlobalDimmerFrameEndInfoFlagsML; + +// Flag bits for XrGlobalDimmerFrameEndInfoFlagsML +static const XrGlobalDimmerFrameEndInfoFlagsML XR_GLOBAL_DIMMER_FRAME_END_INFO_ENABLED_BIT_ML = 0x00000001; + +// XrGlobalDimmerFrameEndInfoML extends XrFrameEndInfo +typedef struct XrGlobalDimmerFrameEndInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + float dimmerValue; + XrGlobalDimmerFrameEndInfoFlagsML flags; +} XrGlobalDimmerFrameEndInfoML; + + + +// XR_ML_marker_understanding is a preprocessor guard. Do not pass it to API calls. +#define XR_ML_marker_understanding 1 +XR_DEFINE_ATOM(XrMarkerML) +XR_DEFINE_HANDLE(XrMarkerDetectorML) +#define XR_ML_marker_understanding_SPEC_VERSION 1 +#define XR_ML_MARKER_UNDERSTANDING_EXTENSION_NAME "XR_ML_marker_understanding" + +typedef enum XrMarkerDetectorProfileML { + XR_MARKER_DETECTOR_PROFILE_DEFAULT_ML = 0, + XR_MARKER_DETECTOR_PROFILE_SPEED_ML = 1, + XR_MARKER_DETECTOR_PROFILE_ACCURACY_ML = 2, + XR_MARKER_DETECTOR_PROFILE_SMALL_TARGETS_ML = 3, + XR_MARKER_DETECTOR_PROFILE_LARGE_FOV_ML = 4, + XR_MARKER_DETECTOR_PROFILE_CUSTOM_ML = 5, + XR_MARKER_DETECTOR_PROFILE_MAX_ENUM_ML = 0x7FFFFFFF +} XrMarkerDetectorProfileML; + +typedef enum XrMarkerTypeML { + XR_MARKER_TYPE_ARUCO_ML = 0, + XR_MARKER_TYPE_APRIL_TAG_ML = 1, + XR_MARKER_TYPE_QR_ML = 2, + XR_MARKER_TYPE_EAN_13_ML = 3, + XR_MARKER_TYPE_UPC_A_ML = 4, + XR_MARKER_TYPE_CODE_128_ML = 5, + XR_MARKER_TYPE_MAX_ENUM_ML = 0x7FFFFFFF +} XrMarkerTypeML; + +typedef enum XrMarkerArucoDictML { + XR_MARKER_ARUCO_DICT_4X4_50_ML = 0, + XR_MARKER_ARUCO_DICT_4X4_100_ML = 1, + XR_MARKER_ARUCO_DICT_4X4_250_ML = 2, + XR_MARKER_ARUCO_DICT_4X4_1000_ML = 3, + XR_MARKER_ARUCO_DICT_5X5_50_ML = 4, + XR_MARKER_ARUCO_DICT_5X5_100_ML = 5, + XR_MARKER_ARUCO_DICT_5X5_250_ML = 6, + XR_MARKER_ARUCO_DICT_5X5_1000_ML = 7, + XR_MARKER_ARUCO_DICT_6X6_50_ML = 8, + XR_MARKER_ARUCO_DICT_6X6_100_ML = 9, + XR_MARKER_ARUCO_DICT_6X6_250_ML = 10, + XR_MARKER_ARUCO_DICT_6X6_1000_ML = 11, + XR_MARKER_ARUCO_DICT_7X7_50_ML = 12, + XR_MARKER_ARUCO_DICT_7X7_100_ML = 13, + XR_MARKER_ARUCO_DICT_7X7_250_ML = 14, + XR_MARKER_ARUCO_DICT_7X7_1000_ML = 15, + XR_MARKER_ARUCO_DICT_MAX_ENUM_ML = 0x7FFFFFFF +} XrMarkerArucoDictML; + +typedef enum XrMarkerAprilTagDictML { + XR_MARKER_APRIL_TAG_DICT_16H5_ML = 0, + XR_MARKER_APRIL_TAG_DICT_25H9_ML = 1, + XR_MARKER_APRIL_TAG_DICT_36H10_ML = 2, + XR_MARKER_APRIL_TAG_DICT_36H11_ML = 3, + XR_MARKER_APRIL_TAG_DICT_MAX_ENUM_ML = 0x7FFFFFFF +} XrMarkerAprilTagDictML; + +typedef enum XrMarkerDetectorFpsML { + XR_MARKER_DETECTOR_FPS_LOW_ML = 0, + XR_MARKER_DETECTOR_FPS_MEDIUM_ML = 1, + XR_MARKER_DETECTOR_FPS_HIGH_ML = 2, + XR_MARKER_DETECTOR_FPS_MAX_ML = 3, + XR_MARKER_DETECTOR_FPS_MAX_ENUM_ML = 0x7FFFFFFF +} XrMarkerDetectorFpsML; + +typedef enum XrMarkerDetectorResolutionML { + XR_MARKER_DETECTOR_RESOLUTION_LOW_ML = 0, + XR_MARKER_DETECTOR_RESOLUTION_MEDIUM_ML = 1, + XR_MARKER_DETECTOR_RESOLUTION_HIGH_ML = 2, + XR_MARKER_DETECTOR_RESOLUTION_MAX_ENUM_ML = 0x7FFFFFFF +} XrMarkerDetectorResolutionML; + +typedef enum XrMarkerDetectorCameraML { + XR_MARKER_DETECTOR_CAMERA_RGB_CAMERA_ML = 0, + XR_MARKER_DETECTOR_CAMERA_WORLD_CAMERAS_ML = 1, + XR_MARKER_DETECTOR_CAMERA_MAX_ENUM_ML = 0x7FFFFFFF +} XrMarkerDetectorCameraML; + +typedef enum XrMarkerDetectorCornerRefineMethodML { + XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_NONE_ML = 0, + XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_SUBPIX_ML = 1, + XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_CONTOUR_ML = 2, + XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_APRIL_TAG_ML = 3, + XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_MAX_ENUM_ML = 0x7FFFFFFF +} XrMarkerDetectorCornerRefineMethodML; + +typedef enum XrMarkerDetectorFullAnalysisIntervalML { + XR_MARKER_DETECTOR_FULL_ANALYSIS_INTERVAL_MAX_ML = 0, + XR_MARKER_DETECTOR_FULL_ANALYSIS_INTERVAL_FAST_ML = 1, + XR_MARKER_DETECTOR_FULL_ANALYSIS_INTERVAL_MEDIUM_ML = 2, + XR_MARKER_DETECTOR_FULL_ANALYSIS_INTERVAL_SLOW_ML = 3, + XR_MARKER_DETECTOR_FULL_ANALYSIS_INTERVAL_MAX_ENUM_ML = 0x7FFFFFFF +} XrMarkerDetectorFullAnalysisIntervalML; + +typedef enum XrMarkerDetectorStatusML { + XR_MARKER_DETECTOR_STATUS_PENDING_ML = 0, + XR_MARKER_DETECTOR_STATUS_READY_ML = 1, + XR_MARKER_DETECTOR_STATUS_ERROR_ML = 2, + XR_MARKER_DETECTOR_STATUS_MAX_ENUM_ML = 0x7FFFFFFF +} XrMarkerDetectorStatusML; +// XrSystemMarkerUnderstandingPropertiesML extends XrSystemProperties +typedef struct XrSystemMarkerUnderstandingPropertiesML { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsMarkerUnderstanding; +} XrSystemMarkerUnderstandingPropertiesML; + +typedef struct XrMarkerDetectorCreateInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrMarkerDetectorProfileML profile; + XrMarkerTypeML markerType; +} XrMarkerDetectorCreateInfoML; + +// XrMarkerDetectorArucoInfoML extends XrMarkerDetectorCreateInfoML +typedef struct XrMarkerDetectorArucoInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrMarkerArucoDictML arucoDict; +} XrMarkerDetectorArucoInfoML; + +// XrMarkerDetectorSizeInfoML extends XrMarkerDetectorCreateInfoML +typedef struct XrMarkerDetectorSizeInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + float markerLength; +} XrMarkerDetectorSizeInfoML; + +// XrMarkerDetectorAprilTagInfoML extends XrMarkerDetectorCreateInfoML +typedef struct XrMarkerDetectorAprilTagInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrMarkerAprilTagDictML aprilTagDict; +} XrMarkerDetectorAprilTagInfoML; + +// XrMarkerDetectorCustomProfileInfoML extends XrMarkerDetectorCreateInfoML +typedef struct XrMarkerDetectorCustomProfileInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrMarkerDetectorFpsML fpsHint; + XrMarkerDetectorResolutionML resolutionHint; + XrMarkerDetectorCameraML cameraHint; + XrMarkerDetectorCornerRefineMethodML cornerRefineMethod; + XrBool32 useEdgeRefinement; + XrMarkerDetectorFullAnalysisIntervalML fullAnalysisIntervalHint; +} XrMarkerDetectorCustomProfileInfoML; + +typedef struct XrMarkerDetectorSnapshotInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrMarkerDetectorSnapshotInfoML; + +typedef struct XrMarkerDetectorStateML { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrMarkerDetectorStatusML state; +} XrMarkerDetectorStateML; + +typedef struct XrMarkerSpaceCreateInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrMarkerDetectorML markerDetector; + XrMarkerML marker; + XrPosef poseInMarkerSpace; +} XrMarkerSpaceCreateInfoML; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateMarkerDetectorML)(XrSession session, const XrMarkerDetectorCreateInfoML* createInfo, XrMarkerDetectorML* markerDetector); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyMarkerDetectorML)(XrMarkerDetectorML markerDetector); +typedef XrResult (XRAPI_PTR *PFN_xrSnapshotMarkerDetectorML)(XrMarkerDetectorML markerDetector, XrMarkerDetectorSnapshotInfoML* snapshotInfo); +typedef XrResult (XRAPI_PTR *PFN_xrGetMarkerDetectorStateML)(XrMarkerDetectorML markerDetector, XrMarkerDetectorStateML* state); +typedef XrResult (XRAPI_PTR *PFN_xrGetMarkersML)(XrMarkerDetectorML markerDetector, uint32_t markerCapacityInput, uint32_t* markerCountOutput, XrMarkerML* markers); +typedef XrResult (XRAPI_PTR *PFN_xrGetMarkerReprojectionErrorML)(XrMarkerDetectorML markerDetector, XrMarkerML marker, float* reprojectionErrorMeters); +typedef XrResult (XRAPI_PTR *PFN_xrGetMarkerLengthML)(XrMarkerDetectorML markerDetector, XrMarkerML marker, float* meters); +typedef XrResult (XRAPI_PTR *PFN_xrGetMarkerNumberML)(XrMarkerDetectorML markerDetector, XrMarkerML marker, uint64_t* number); +typedef XrResult (XRAPI_PTR *PFN_xrGetMarkerStringML)(XrMarkerDetectorML markerDetector, XrMarkerML marker, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, char* buffer); +typedef XrResult (XRAPI_PTR *PFN_xrCreateMarkerSpaceML)(XrSession session, const XrMarkerSpaceCreateInfoML* createInfo, XrSpace* space); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateMarkerDetectorML( + XrSession session, + const XrMarkerDetectorCreateInfoML* createInfo, + XrMarkerDetectorML* markerDetector); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyMarkerDetectorML( + XrMarkerDetectorML markerDetector); + +XRAPI_ATTR XrResult XRAPI_CALL xrSnapshotMarkerDetectorML( + XrMarkerDetectorML markerDetector, + XrMarkerDetectorSnapshotInfoML* snapshotInfo); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetMarkerDetectorStateML( + XrMarkerDetectorML markerDetector, + XrMarkerDetectorStateML* state); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetMarkersML( + XrMarkerDetectorML markerDetector, + uint32_t markerCapacityInput, + uint32_t* markerCountOutput, + XrMarkerML* markers); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetMarkerReprojectionErrorML( + XrMarkerDetectorML markerDetector, + XrMarkerML marker, + float* reprojectionErrorMeters); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetMarkerLengthML( + XrMarkerDetectorML markerDetector, + XrMarkerML marker, + float* meters); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetMarkerNumberML( + XrMarkerDetectorML markerDetector, + XrMarkerML marker, + uint64_t* number); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetMarkerStringML( + XrMarkerDetectorML markerDetector, + XrMarkerML marker, + uint32_t bufferCapacityInput, + uint32_t* bufferCountOutput, + char* buffer); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateMarkerSpaceML( + XrSession session, + const XrMarkerSpaceCreateInfoML* createInfo, + XrSpace* space); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ML_localization_map is a preprocessor guard. Do not pass it to API calls. +#define XR_ML_localization_map 1 +XR_DEFINE_HANDLE(XrExportedLocalizationMapML) +#define XR_MAX_LOCALIZATION_MAP_NAME_LENGTH_ML 64 +#define XR_ML_localization_map_SPEC_VERSION 1 +#define XR_ML_LOCALIZATION_MAP_EXTENSION_NAME "XR_ML_localization_map" + +typedef enum XrLocalizationMapStateML { + XR_LOCALIZATION_MAP_STATE_NOT_LOCALIZED_ML = 0, + XR_LOCALIZATION_MAP_STATE_LOCALIZED_ML = 1, + XR_LOCALIZATION_MAP_STATE_LOCALIZATION_PENDING_ML = 2, + XR_LOCALIZATION_MAP_STATE_LOCALIZATION_SLEEPING_BEFORE_RETRY_ML = 3, + XR_LOCALIZATION_MAP_STATE_MAX_ENUM_ML = 0x7FFFFFFF +} XrLocalizationMapStateML; + +typedef enum XrLocalizationMapTypeML { + XR_LOCALIZATION_MAP_TYPE_ON_DEVICE_ML = 0, + XR_LOCALIZATION_MAP_TYPE_CLOUD_ML = 1, + XR_LOCALIZATION_MAP_TYPE_MAX_ENUM_ML = 0x7FFFFFFF +} XrLocalizationMapTypeML; + +typedef enum XrLocalizationMapConfidenceML { + XR_LOCALIZATION_MAP_CONFIDENCE_POOR_ML = 0, + XR_LOCALIZATION_MAP_CONFIDENCE_FAIR_ML = 1, + XR_LOCALIZATION_MAP_CONFIDENCE_GOOD_ML = 2, + XR_LOCALIZATION_MAP_CONFIDENCE_EXCELLENT_ML = 3, + XR_LOCALIZATION_MAP_CONFIDENCE_MAX_ENUM_ML = 0x7FFFFFFF +} XrLocalizationMapConfidenceML; +typedef XrFlags64 XrLocalizationMapErrorFlagsML; + +// Flag bits for XrLocalizationMapErrorFlagsML +static const XrLocalizationMapErrorFlagsML XR_LOCALIZATION_MAP_ERROR_UNKNOWN_BIT_ML = 0x00000001; +static const XrLocalizationMapErrorFlagsML XR_LOCALIZATION_MAP_ERROR_OUT_OF_MAPPED_AREA_BIT_ML = 0x00000002; +static const XrLocalizationMapErrorFlagsML XR_LOCALIZATION_MAP_ERROR_LOW_FEATURE_COUNT_BIT_ML = 0x00000004; +static const XrLocalizationMapErrorFlagsML XR_LOCALIZATION_MAP_ERROR_EXCESSIVE_MOTION_BIT_ML = 0x00000008; +static const XrLocalizationMapErrorFlagsML XR_LOCALIZATION_MAP_ERROR_LOW_LIGHT_BIT_ML = 0x00000010; +static const XrLocalizationMapErrorFlagsML XR_LOCALIZATION_MAP_ERROR_HEADPOSE_BIT_ML = 0x00000020; + +typedef struct XrLocalizationMapML { + XrStructureType type; + void* XR_MAY_ALIAS next; + char name[XR_MAX_LOCALIZATION_MAP_NAME_LENGTH_ML]; + XrUuidEXT mapUuid; + XrLocalizationMapTypeML mapType; +} XrLocalizationMapML; + +typedef struct XrEventDataLocalizationChangedML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSession session; + XrLocalizationMapStateML state; + XrLocalizationMapML map; + XrLocalizationMapConfidenceML confidence; + XrLocalizationMapErrorFlagsML errorFlags; +} XrEventDataLocalizationChangedML; + +typedef struct XrLocalizationMapQueryInfoBaseHeaderML { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrLocalizationMapQueryInfoBaseHeaderML; + +typedef struct XrMapLocalizationRequestInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrUuidEXT mapUuid; +} XrMapLocalizationRequestInfoML; + +typedef struct XrLocalizationMapImportInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t size; + char* data; +} XrLocalizationMapImportInfoML; + +typedef struct XrLocalizationEnableEventsInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 enabled; +} XrLocalizationEnableEventsInfoML; + +typedef XrResult (XRAPI_PTR *PFN_xrEnableLocalizationEventsML)(XrSession session, const XrLocalizationEnableEventsInfoML * info); +typedef XrResult (XRAPI_PTR *PFN_xrQueryLocalizationMapsML)(XrSession session, const XrLocalizationMapQueryInfoBaseHeaderML* queryInfo, uint32_t mapCapacityInput, uint32_t * mapCountOutput, XrLocalizationMapML* maps); +typedef XrResult (XRAPI_PTR *PFN_xrRequestMapLocalizationML)(XrSession session, const XrMapLocalizationRequestInfoML* requestInfo); +typedef XrResult (XRAPI_PTR *PFN_xrImportLocalizationMapML)(XrSession session, const XrLocalizationMapImportInfoML* importInfo, XrUuidEXT* mapUuid); +typedef XrResult (XRAPI_PTR *PFN_xrCreateExportedLocalizationMapML)(XrSession session, const XrUuidEXT* mapUuid, XrExportedLocalizationMapML* map); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyExportedLocalizationMapML)(XrExportedLocalizationMapML map); +typedef XrResult (XRAPI_PTR *PFN_xrGetExportedLocalizationMapDataML)(XrExportedLocalizationMapML map, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, char* buffer); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnableLocalizationEventsML( + XrSession session, + const XrLocalizationEnableEventsInfoML * info); + +XRAPI_ATTR XrResult XRAPI_CALL xrQueryLocalizationMapsML( + XrSession session, + const XrLocalizationMapQueryInfoBaseHeaderML* queryInfo, + uint32_t mapCapacityInput, + uint32_t * mapCountOutput, + XrLocalizationMapML* maps); + +XRAPI_ATTR XrResult XRAPI_CALL xrRequestMapLocalizationML( + XrSession session, + const XrMapLocalizationRequestInfoML* requestInfo); + +XRAPI_ATTR XrResult XRAPI_CALL xrImportLocalizationMapML( + XrSession session, + const XrLocalizationMapImportInfoML* importInfo, + XrUuidEXT* mapUuid); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateExportedLocalizationMapML( + XrSession session, + const XrUuidEXT* mapUuid, + XrExportedLocalizationMapML* map); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyExportedLocalizationMapML( + XrExportedLocalizationMapML map); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetExportedLocalizationMapDataML( + XrExportedLocalizationMapML map, + uint32_t bufferCapacityInput, + uint32_t* bufferCountOutput, + char* buffer); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ML_spatial_anchors is a preprocessor guard. Do not pass it to API calls. +#define XR_ML_spatial_anchors 1 +XR_DEFINE_OPAQUE_64(XrFutureEXT) +#define XR_ML_spatial_anchors_SPEC_VERSION 1 +#define XR_ML_SPATIAL_ANCHORS_EXTENSION_NAME "XR_ML_spatial_anchors" + +typedef enum XrSpatialAnchorConfidenceML { + XR_SPATIAL_ANCHOR_CONFIDENCE_LOW_ML = 0, + XR_SPATIAL_ANCHOR_CONFIDENCE_MEDIUM_ML = 1, + XR_SPATIAL_ANCHOR_CONFIDENCE_HIGH_ML = 2, + XR_SPATIAL_ANCHOR_CONFIDENCE_MAX_ENUM_ML = 0x7FFFFFFF +} XrSpatialAnchorConfidenceML; +typedef struct XR_MAY_ALIAS XrSpatialAnchorsCreateInfoBaseHeaderML { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrSpatialAnchorsCreateInfoBaseHeaderML; + +typedef struct XrSpatialAnchorsCreateInfoFromPoseML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace baseSpace; + XrPosef poseInBaseSpace; + XrTime time; +} XrSpatialAnchorsCreateInfoFromPoseML; + +typedef struct XrCreateSpatialAnchorsCompletionML { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrResult futureResult; + uint32_t spaceCount; + XrSpace* spaces; +} XrCreateSpatialAnchorsCompletionML; + +typedef struct XrSpatialAnchorStateML { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrSpatialAnchorConfidenceML confidence; +} XrSpatialAnchorStateML; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorsAsyncML)(XrSession session, const XrSpatialAnchorsCreateInfoBaseHeaderML* createInfo, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorsCompleteML)(XrSession session, XrFutureEXT future, XrCreateSpatialAnchorsCompletionML* completion); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialAnchorStateML)(XrSpace anchor, XrSpatialAnchorStateML* state); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorsAsyncML( + XrSession session, + const XrSpatialAnchorsCreateInfoBaseHeaderML* createInfo, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorsCompleteML( + XrSession session, + XrFutureEXT future, + XrCreateSpatialAnchorsCompletionML* completion); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialAnchorStateML( + XrSpace anchor, + XrSpatialAnchorStateML* state); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ML_spatial_anchors_storage is a preprocessor guard. Do not pass it to API calls. +#define XR_ML_spatial_anchors_storage 1 +XR_DEFINE_HANDLE(XrSpatialAnchorsStorageML) +#define XR_ML_spatial_anchors_storage_SPEC_VERSION 1 +#define XR_ML_SPATIAL_ANCHORS_STORAGE_EXTENSION_NAME "XR_ML_spatial_anchors_storage" +typedef struct XrSpatialAnchorsCreateStorageInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrSpatialAnchorsCreateStorageInfoML; + +typedef struct XR_MAY_ALIAS XrSpatialAnchorsQueryInfoBaseHeaderML { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrSpatialAnchorsQueryInfoBaseHeaderML; + +typedef struct XrSpatialAnchorsQueryInfoRadiusML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace baseSpace; + XrVector3f center; + XrTime time; + float radius; +} XrSpatialAnchorsQueryInfoRadiusML; + +typedef struct XrSpatialAnchorsQueryCompletionML { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrResult futureResult; + uint32_t uuidCapacityInput; + uint32_t uuidCountOutput; + XrUuidEXT* uuids; +} XrSpatialAnchorsQueryCompletionML; + +typedef struct XrSpatialAnchorsCreateInfoFromUuidsML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialAnchorsStorageML storage; + uint32_t uuidCount; + const XrUuidEXT* uuids; +} XrSpatialAnchorsCreateInfoFromUuidsML; + +typedef struct XrSpatialAnchorsPublishInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t anchorCount; + const XrSpace* anchors; + uint64_t expiration; +} XrSpatialAnchorsPublishInfoML; + +typedef struct XrSpatialAnchorsPublishCompletionML { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrResult futureResult; + uint32_t uuidCount; + XrUuidEXT* uuids; +} XrSpatialAnchorsPublishCompletionML; + +typedef struct XrSpatialAnchorsDeleteInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t uuidCount; + const XrUuidEXT* uuids; +} XrSpatialAnchorsDeleteInfoML; + +typedef struct XrSpatialAnchorsDeleteCompletionML { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrResult futureResult; +} XrSpatialAnchorsDeleteCompletionML; + +typedef struct XrSpatialAnchorsUpdateExpirationInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t uuidCount; + const XrUuidEXT* uuids; + uint64_t expiration; +} XrSpatialAnchorsUpdateExpirationInfoML; + +typedef struct XrSpatialAnchorsUpdateExpirationCompletionML { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrResult futureResult; +} XrSpatialAnchorsUpdateExpirationCompletionML; + +typedef struct XrSpatialAnchorCompletionResultML { + XrUuidEXT uuid; + XrResult result; +} XrSpatialAnchorCompletionResultML; + +// XrSpatialAnchorsPublishCompletionDetailsML extends XrSpatialAnchorsPublishCompletionML +typedef struct XrSpatialAnchorsPublishCompletionDetailsML { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t resultCount; + XrSpatialAnchorCompletionResultML* results; +} XrSpatialAnchorsPublishCompletionDetailsML; + +// XrSpatialAnchorsDeleteCompletionDetailsML extends XrSpatialAnchorsDeleteCompletionML +typedef struct XrSpatialAnchorsDeleteCompletionDetailsML { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t resultCount; + XrSpatialAnchorCompletionResultML* results; +} XrSpatialAnchorsDeleteCompletionDetailsML; + +// XrSpatialAnchorsUpdateExpirationCompletionDetailsML extends XrSpatialAnchorsUpdateExpirationCompletionML +typedef struct XrSpatialAnchorsUpdateExpirationCompletionDetailsML { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t resultCount; + XrSpatialAnchorCompletionResultML* results; +} XrSpatialAnchorsUpdateExpirationCompletionDetailsML; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorsStorageML)(XrSession session, const XrSpatialAnchorsCreateStorageInfoML* createInfo, XrSpatialAnchorsStorageML* storage); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialAnchorsStorageML)(XrSpatialAnchorsStorageML storage); +typedef XrResult (XRAPI_PTR *PFN_xrQuerySpatialAnchorsAsyncML)(XrSpatialAnchorsStorageML storage, const XrSpatialAnchorsQueryInfoBaseHeaderML* queryInfo, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrQuerySpatialAnchorsCompleteML)(XrSpatialAnchorsStorageML storage, XrFutureEXT future, XrSpatialAnchorsQueryCompletionML* completion); +typedef XrResult (XRAPI_PTR *PFN_xrPublishSpatialAnchorsAsyncML)(XrSpatialAnchorsStorageML storage, const XrSpatialAnchorsPublishInfoML* publishInfo, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrPublishSpatialAnchorsCompleteML)(XrSpatialAnchorsStorageML storage, XrFutureEXT future, XrSpatialAnchorsPublishCompletionML* completion); +typedef XrResult (XRAPI_PTR *PFN_xrDeleteSpatialAnchorsAsyncML)(XrSpatialAnchorsStorageML storage, const XrSpatialAnchorsDeleteInfoML* deleteInfo, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrDeleteSpatialAnchorsCompleteML)(XrSpatialAnchorsStorageML storage, XrFutureEXT future, XrSpatialAnchorsDeleteCompletionML* completion); +typedef XrResult (XRAPI_PTR *PFN_xrUpdateSpatialAnchorsExpirationAsyncML)(XrSpatialAnchorsStorageML storage, const XrSpatialAnchorsUpdateExpirationInfoML* updateInfo, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrUpdateSpatialAnchorsExpirationCompleteML)(XrSpatialAnchorsStorageML storage, XrFutureEXT future, XrSpatialAnchorsUpdateExpirationCompletionML* completion); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorsStorageML( + XrSession session, + const XrSpatialAnchorsCreateStorageInfoML* createInfo, + XrSpatialAnchorsStorageML* storage); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialAnchorsStorageML( + XrSpatialAnchorsStorageML storage); + +XRAPI_ATTR XrResult XRAPI_CALL xrQuerySpatialAnchorsAsyncML( + XrSpatialAnchorsStorageML storage, + const XrSpatialAnchorsQueryInfoBaseHeaderML* queryInfo, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrQuerySpatialAnchorsCompleteML( + XrSpatialAnchorsStorageML storage, + XrFutureEXT future, + XrSpatialAnchorsQueryCompletionML* completion); + +XRAPI_ATTR XrResult XRAPI_CALL xrPublishSpatialAnchorsAsyncML( + XrSpatialAnchorsStorageML storage, + const XrSpatialAnchorsPublishInfoML* publishInfo, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrPublishSpatialAnchorsCompleteML( + XrSpatialAnchorsStorageML storage, + XrFutureEXT future, + XrSpatialAnchorsPublishCompletionML* completion); + +XRAPI_ATTR XrResult XRAPI_CALL xrDeleteSpatialAnchorsAsyncML( + XrSpatialAnchorsStorageML storage, + const XrSpatialAnchorsDeleteInfoML* deleteInfo, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrDeleteSpatialAnchorsCompleteML( + XrSpatialAnchorsStorageML storage, + XrFutureEXT future, + XrSpatialAnchorsDeleteCompletionML* completion); + +XRAPI_ATTR XrResult XRAPI_CALL xrUpdateSpatialAnchorsExpirationAsyncML( + XrSpatialAnchorsStorageML storage, + const XrSpatialAnchorsUpdateExpirationInfoML* updateInfo, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrUpdateSpatialAnchorsExpirationCompleteML( + XrSpatialAnchorsStorageML storage, + XrFutureEXT future, + XrSpatialAnchorsUpdateExpirationCompletionML* completion); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_MSFT_spatial_anchor_persistence is a preprocessor guard. Do not pass it to API calls. +#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 spatialAnchorNameCapacityInput, uint32_t* spatialAnchorNameCountOutput, XrSpatialAnchorPersistenceNameMSFT* spatialAnchorNames); +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 spatialAnchorNameCapacityInput, + uint32_t* spatialAnchorNameCountOutput, + XrSpatialAnchorPersistenceNameMSFT* spatialAnchorNames); + +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 */ + + +// XR_MSFT_scene_marker is a preprocessor guard. Do not pass it to API calls. +#define XR_MSFT_scene_marker 1 +#define XR_MSFT_scene_marker_SPEC_VERSION 1 +#define XR_MSFT_SCENE_MARKER_EXTENSION_NAME "XR_MSFT_scene_marker" + +typedef enum XrSceneMarkerTypeMSFT { + XR_SCENE_MARKER_TYPE_QR_CODE_MSFT = 1, + XR_SCENE_MARKER_TYPE_MAX_ENUM_MSFT = 0x7FFFFFFF +} XrSceneMarkerTypeMSFT; + +typedef enum XrSceneMarkerQRCodeSymbolTypeMSFT { + XR_SCENE_MARKER_QR_CODE_SYMBOL_TYPE_QR_CODE_MSFT = 1, + XR_SCENE_MARKER_QR_CODE_SYMBOL_TYPE_MICRO_QR_CODE_MSFT = 2, + XR_SCENE_MARKER_QRCODE_SYMBOL_TYPE_MAX_ENUM_MSFT = 0x7FFFFFFF +} XrSceneMarkerQRCodeSymbolTypeMSFT; +typedef struct XrSceneMarkerMSFT { + XrSceneMarkerTypeMSFT markerType; + XrTime lastSeenTime; + XrOffset2Df center; + XrExtent2Df size; +} XrSceneMarkerMSFT; + +// XrSceneMarkersMSFT extends XrSceneComponentsMSFT +typedef struct XrSceneMarkersMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t sceneMarkerCapacityInput; + XrSceneMarkerMSFT* sceneMarkers; +} XrSceneMarkersMSFT; + +// XrSceneMarkerTypeFilterMSFT extends XrSceneComponentsGetInfoMSFT +typedef struct XrSceneMarkerTypeFilterMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t markerTypeCount; + XrSceneMarkerTypeMSFT* markerTypes; +} XrSceneMarkerTypeFilterMSFT; + +typedef struct XrSceneMarkerQRCodeMSFT { + XrSceneMarkerQRCodeSymbolTypeMSFT symbolType; + uint8_t version; +} XrSceneMarkerQRCodeMSFT; + +// XrSceneMarkerQRCodesMSFT extends XrSceneComponentsMSFT +typedef struct XrSceneMarkerQRCodesMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t qrCodeCapacityInput; + XrSceneMarkerQRCodeMSFT* qrCodes; +} XrSceneMarkerQRCodesMSFT; + +typedef XrResult (XRAPI_PTR *PFN_xrGetSceneMarkerRawDataMSFT)(XrSceneMSFT scene, const XrUuidMSFT* markerId, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, uint8_t* buffer); +typedef XrResult (XRAPI_PTR *PFN_xrGetSceneMarkerDecodedStringMSFT)(XrSceneMSFT scene, const XrUuidMSFT* markerId, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, char* buffer); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetSceneMarkerRawDataMSFT( + XrSceneMSFT scene, + const XrUuidMSFT* markerId, + uint32_t bufferCapacityInput, + uint32_t* bufferCountOutput, + uint8_t* buffer); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSceneMarkerDecodedStringMSFT( + XrSceneMSFT scene, + const XrUuidMSFT* markerId, + uint32_t bufferCapacityInput, + uint32_t* bufferCountOutput, + char* buffer); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ULTRALEAP_hand_tracking_forearm is a preprocessor guard. Do not pass it to API calls. +#define XR_ULTRALEAP_hand_tracking_forearm 1 + +#define XR_HAND_FOREARM_JOINT_COUNT_ULTRALEAP 27 + +#define XR_ULTRALEAP_hand_tracking_forearm_SPEC_VERSION 1 +#define XR_ULTRALEAP_HAND_TRACKING_FOREARM_EXTENSION_NAME "XR_ULTRALEAP_hand_tracking_forearm" + +typedef enum XrHandForearmJointULTRALEAP { + XR_HAND_FOREARM_JOINT_PALM_ULTRALEAP = 0, + XR_HAND_FOREARM_JOINT_WRIST_ULTRALEAP = 1, + XR_HAND_FOREARM_JOINT_THUMB_METACARPAL_ULTRALEAP = 2, + XR_HAND_FOREARM_JOINT_THUMB_PROXIMAL_ULTRALEAP = 3, + XR_HAND_FOREARM_JOINT_THUMB_DISTAL_ULTRALEAP = 4, + XR_HAND_FOREARM_JOINT_THUMB_TIP_ULTRALEAP = 5, + XR_HAND_FOREARM_JOINT_INDEX_METACARPAL_ULTRALEAP = 6, + XR_HAND_FOREARM_JOINT_INDEX_PROXIMAL_ULTRALEAP = 7, + XR_HAND_FOREARM_JOINT_INDEX_INTERMEDIATE_ULTRALEAP = 8, + XR_HAND_FOREARM_JOINT_INDEX_DISTAL_ULTRALEAP = 9, + XR_HAND_FOREARM_JOINT_INDEX_TIP_ULTRALEAP = 10, + XR_HAND_FOREARM_JOINT_MIDDLE_METACARPAL_ULTRALEAP = 11, + XR_HAND_FOREARM_JOINT_MIDDLE_PROXIMAL_ULTRALEAP = 12, + XR_HAND_FOREARM_JOINT_MIDDLE_INTERMEDIATE_ULTRALEAP = 13, + XR_HAND_FOREARM_JOINT_MIDDLE_DISTAL_ULTRALEAP = 14, + XR_HAND_FOREARM_JOINT_MIDDLE_TIP_ULTRALEAP = 15, + XR_HAND_FOREARM_JOINT_RING_METACARPAL_ULTRALEAP = 16, + XR_HAND_FOREARM_JOINT_RING_PROXIMAL_ULTRALEAP = 17, + XR_HAND_FOREARM_JOINT_RING_INTERMEDIATE_ULTRALEAP = 18, + XR_HAND_FOREARM_JOINT_RING_DISTAL_ULTRALEAP = 19, + XR_HAND_FOREARM_JOINT_RING_TIP_ULTRALEAP = 20, + XR_HAND_FOREARM_JOINT_LITTLE_METACARPAL_ULTRALEAP = 21, + XR_HAND_FOREARM_JOINT_LITTLE_PROXIMAL_ULTRALEAP = 22, + XR_HAND_FOREARM_JOINT_LITTLE_INTERMEDIATE_ULTRALEAP = 23, + XR_HAND_FOREARM_JOINT_LITTLE_DISTAL_ULTRALEAP = 24, + XR_HAND_FOREARM_JOINT_LITTLE_TIP_ULTRALEAP = 25, + XR_HAND_FOREARM_JOINT_ELBOW_ULTRALEAP = 26, + XR_HAND_FOREARM_JOINT_MAX_ENUM_ULTRALEAP = 0x7FFFFFFF +} XrHandForearmJointULTRALEAP; + + +// XR_FB_spatial_entity_query is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_spatial_entity_query 1 +#define XR_FB_spatial_entity_query_SPEC_VERSION 1 +#define XR_FB_SPATIAL_ENTITY_QUERY_EXTENSION_NAME "XR_FB_spatial_entity_query" + +typedef enum XrSpaceQueryActionFB { + XR_SPACE_QUERY_ACTION_LOAD_FB = 0, + XR_SPACE_QUERY_ACTION_MAX_ENUM_FB = 0x7FFFFFFF +} XrSpaceQueryActionFB; + +typedef enum XrSpaceStorageLocationFB { + XR_SPACE_STORAGE_LOCATION_INVALID_FB = 0, + XR_SPACE_STORAGE_LOCATION_LOCAL_FB = 1, + XR_SPACE_STORAGE_LOCATION_CLOUD_FB = 2, + XR_SPACE_STORAGE_LOCATION_MAX_ENUM_FB = 0x7FFFFFFF +} XrSpaceStorageLocationFB; +typedef struct XR_MAY_ALIAS XrSpaceQueryInfoBaseHeaderFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrSpaceQueryInfoBaseHeaderFB; + +typedef struct XR_MAY_ALIAS XrSpaceFilterInfoBaseHeaderFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrSpaceFilterInfoBaseHeaderFB; + +typedef struct XrSpaceQueryInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpaceQueryActionFB queryAction; + uint32_t maxResultCount; + XrDuration timeout; + const XrSpaceFilterInfoBaseHeaderFB* filter; + const XrSpaceFilterInfoBaseHeaderFB* excludeFilter; +} XrSpaceQueryInfoFB; + +// XrSpaceStorageLocationFilterInfoFB extends XrSpaceFilterInfoBaseHeaderFB +typedef struct XrSpaceStorageLocationFilterInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpaceStorageLocationFB location; +} XrSpaceStorageLocationFilterInfoFB; + +typedef struct XrSpaceUuidFilterInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t uuidCount; + XrUuidEXT* uuids; +} XrSpaceUuidFilterInfoFB; + +typedef struct XrSpaceComponentFilterInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpaceComponentTypeFB componentType; +} XrSpaceComponentFilterInfoFB; + +typedef struct XrSpaceQueryResultFB { + XrSpace space; + XrUuidEXT uuid; +} XrSpaceQueryResultFB; + +typedef struct XrSpaceQueryResultsFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t resultCapacityInput; + uint32_t resultCountOutput; + XrSpaceQueryResultFB* results; +} XrSpaceQueryResultsFB; + +typedef struct XrEventDataSpaceQueryResultsAvailableFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAsyncRequestIdFB requestId; +} XrEventDataSpaceQueryResultsAvailableFB; + +typedef struct XrEventDataSpaceQueryCompleteFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAsyncRequestIdFB requestId; + XrResult result; +} XrEventDataSpaceQueryCompleteFB; + +typedef XrResult (XRAPI_PTR *PFN_xrQuerySpacesFB)(XrSession session, const XrSpaceQueryInfoBaseHeaderFB* info, XrAsyncRequestIdFB* requestId); +typedef XrResult (XRAPI_PTR *PFN_xrRetrieveSpaceQueryResultsFB)(XrSession session, XrAsyncRequestIdFB requestId, XrSpaceQueryResultsFB* results); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrQuerySpacesFB( + XrSession session, + const XrSpaceQueryInfoBaseHeaderFB* info, + XrAsyncRequestIdFB* requestId); + +XRAPI_ATTR XrResult XRAPI_CALL xrRetrieveSpaceQueryResultsFB( + XrSession session, + XrAsyncRequestIdFB requestId, + XrSpaceQueryResultsFB* results); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_FB_spatial_entity_storage is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_spatial_entity_storage 1 +#define XR_FB_spatial_entity_storage_SPEC_VERSION 1 +#define XR_FB_SPATIAL_ENTITY_STORAGE_EXTENSION_NAME "XR_FB_spatial_entity_storage" + +typedef enum XrSpacePersistenceModeFB { + XR_SPACE_PERSISTENCE_MODE_INVALID_FB = 0, + XR_SPACE_PERSISTENCE_MODE_INDEFINITE_FB = 1, + XR_SPACE_PERSISTENCE_MODE_MAX_ENUM_FB = 0x7FFFFFFF +} XrSpacePersistenceModeFB; +typedef struct XrSpaceSaveInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace space; + XrSpaceStorageLocationFB location; + XrSpacePersistenceModeFB persistenceMode; +} XrSpaceSaveInfoFB; + +typedef struct XrSpaceEraseInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace space; + XrSpaceStorageLocationFB location; +} XrSpaceEraseInfoFB; + +typedef struct XrEventDataSpaceSaveCompleteFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAsyncRequestIdFB requestId; + XrResult result; + XrSpace space; + XrUuidEXT uuid; + XrSpaceStorageLocationFB location; +} XrEventDataSpaceSaveCompleteFB; + +typedef struct XrEventDataSpaceEraseCompleteFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAsyncRequestIdFB requestId; + XrResult result; + XrSpace space; + XrUuidEXT uuid; + XrSpaceStorageLocationFB location; +} XrEventDataSpaceEraseCompleteFB; + +typedef XrResult (XRAPI_PTR *PFN_xrSaveSpaceFB)(XrSession session, const XrSpaceSaveInfoFB* info, XrAsyncRequestIdFB* requestId); +typedef XrResult (XRAPI_PTR *PFN_xrEraseSpaceFB)(XrSession session, const XrSpaceEraseInfoFB* info, XrAsyncRequestIdFB* requestId); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrSaveSpaceFB( + XrSession session, + const XrSpaceSaveInfoFB* info, + XrAsyncRequestIdFB* requestId); + +XRAPI_ATTR XrResult XRAPI_CALL xrEraseSpaceFB( + XrSession session, + const XrSpaceEraseInfoFB* info, + XrAsyncRequestIdFB* requestId); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_FB_touch_controller_pro is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_touch_controller_pro 1 +#define XR_FB_touch_controller_pro_SPEC_VERSION 1 +#define XR_FB_TOUCH_CONTROLLER_PRO_EXTENSION_NAME "XR_FB_touch_controller_pro" + + +// XR_FB_spatial_entity_sharing is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_spatial_entity_sharing 1 +XR_DEFINE_HANDLE(XrSpaceUserFB) +#define XR_FB_spatial_entity_sharing_SPEC_VERSION 1 +#define XR_FB_SPATIAL_ENTITY_SHARING_EXTENSION_NAME "XR_FB_spatial_entity_sharing" +typedef struct XrSpaceShareInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t spaceCount; + XrSpace* spaces; + uint32_t userCount; + XrSpaceUserFB* users; +} XrSpaceShareInfoFB; + +typedef struct XrEventDataSpaceShareCompleteFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAsyncRequestIdFB requestId; + XrResult result; +} XrEventDataSpaceShareCompleteFB; + +typedef XrResult (XRAPI_PTR *PFN_xrShareSpacesFB)(XrSession session, const XrSpaceShareInfoFB* info, XrAsyncRequestIdFB* requestId); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrShareSpacesFB( + XrSession session, + const XrSpaceShareInfoFB* info, + XrAsyncRequestIdFB* requestId); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_FB_space_warp is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_space_warp 1 +#define XR_FB_space_warp_SPEC_VERSION 2 +#define XR_FB_SPACE_WARP_EXTENSION_NAME "XR_FB_space_warp" +typedef XrFlags64 XrCompositionLayerSpaceWarpInfoFlagsFB; + +// Flag bits for XrCompositionLayerSpaceWarpInfoFlagsFB +static const XrCompositionLayerSpaceWarpInfoFlagsFB XR_COMPOSITION_LAYER_SPACE_WARP_INFO_FRAME_SKIP_BIT_FB = 0x00000001; + +// 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; + + + +// XR_FB_haptic_amplitude_envelope is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_haptic_amplitude_envelope 1 + +#define XR_MAX_HAPTIC_AMPLITUDE_ENVELOPE_SAMPLES_FB 4000u + +#define XR_FB_haptic_amplitude_envelope_SPEC_VERSION 1 +#define XR_FB_HAPTIC_AMPLITUDE_ENVELOPE_EXTENSION_NAME "XR_FB_haptic_amplitude_envelope" +typedef struct XrHapticAmplitudeEnvelopeVibrationFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrDuration duration; + uint32_t amplitudeCount; + const float* amplitudes; +} XrHapticAmplitudeEnvelopeVibrationFB; + + + +// XR_FB_scene is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_scene 1 +#define XR_FB_scene_SPEC_VERSION 4 +#define XR_FB_SCENE_EXTENSION_NAME "XR_FB_scene" +typedef XrFlags64 XrSemanticLabelsSupportFlagsFB; + +// Flag bits for XrSemanticLabelsSupportFlagsFB +static const XrSemanticLabelsSupportFlagsFB XR_SEMANTIC_LABELS_SUPPORT_MULTIPLE_SEMANTIC_LABELS_BIT_FB = 0x00000001; +static const XrSemanticLabelsSupportFlagsFB XR_SEMANTIC_LABELS_SUPPORT_ACCEPT_DESK_TO_TABLE_MIGRATION_BIT_FB = 0x00000002; +static const XrSemanticLabelsSupportFlagsFB XR_SEMANTIC_LABELS_SUPPORT_ACCEPT_INVISIBLE_WALL_FACE_BIT_FB = 0x00000004; + +typedef XrExtent3Df XrExtent3DfFB; + +typedef struct XrOffset3DfFB { + float x; + float y; + float z; +} XrOffset3DfFB; + +typedef struct XrRect3DfFB { + XrOffset3DfFB offset; + XrExtent3DfFB extent; +} XrRect3DfFB; + +typedef struct XrSemanticLabelsFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t bufferCapacityInput; + uint32_t bufferCountOutput; + char* buffer; +} XrSemanticLabelsFB; + +typedef struct XrRoomLayoutFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrUuidEXT floorUuid; + XrUuidEXT ceilingUuid; + uint32_t wallUuidCapacityInput; + uint32_t wallUuidCountOutput; + XrUuidEXT* wallUuids; +} XrRoomLayoutFB; + +typedef struct XrBoundary2DFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t vertexCapacityInput; + uint32_t vertexCountOutput; + XrVector2f* vertices; +} XrBoundary2DFB; + +// XrSemanticLabelsSupportInfoFB extends XrSemanticLabelsFB +typedef struct XrSemanticLabelsSupportInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSemanticLabelsSupportFlagsFB flags; + const char* recognizedLabels; +} XrSemanticLabelsSupportInfoFB; + +typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceBoundingBox2DFB)(XrSession session, XrSpace space, XrRect2Df* boundingBox2DOutput); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceBoundingBox3DFB)(XrSession session, XrSpace space, XrRect3DfFB* boundingBox3DOutput); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceSemanticLabelsFB)(XrSession session, XrSpace space, XrSemanticLabelsFB* semanticLabelsOutput); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceBoundary2DFB)(XrSession session, XrSpace space, XrBoundary2DFB* boundary2DOutput); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceRoomLayoutFB)(XrSession session, XrSpace space, XrRoomLayoutFB* roomLayoutOutput); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceBoundingBox2DFB( + XrSession session, + XrSpace space, + XrRect2Df* boundingBox2DOutput); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceBoundingBox3DFB( + XrSession session, + XrSpace space, + XrRect3DfFB* boundingBox3DOutput); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceSemanticLabelsFB( + XrSession session, + XrSpace space, + XrSemanticLabelsFB* semanticLabelsOutput); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceBoundary2DFB( + XrSession session, + XrSpace space, + XrBoundary2DFB* boundary2DOutput); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceRoomLayoutFB( + XrSession session, + XrSpace space, + XrRoomLayoutFB* roomLayoutOutput); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_EXT_palm_pose is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_palm_pose 1 +#define XR_EXT_palm_pose_SPEC_VERSION 3 +#define XR_EXT_PALM_POSE_EXTENSION_NAME "XR_EXT_palm_pose" + + +// XR_ALMALENCE_digital_lens_control is a preprocessor guard. Do not pass it to API calls. +#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 */ + + +// XR_FB_scene_capture is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_scene_capture 1 +#define XR_FB_scene_capture_SPEC_VERSION 1 +#define XR_FB_SCENE_CAPTURE_EXTENSION_NAME "XR_FB_scene_capture" +typedef struct XrEventDataSceneCaptureCompleteFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAsyncRequestIdFB requestId; + XrResult result; +} XrEventDataSceneCaptureCompleteFB; + +typedef struct XrSceneCaptureRequestInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t requestByteCount; + const char* request; +} XrSceneCaptureRequestInfoFB; + +typedef XrResult (XRAPI_PTR *PFN_xrRequestSceneCaptureFB)(XrSession session, const XrSceneCaptureRequestInfoFB* info, XrAsyncRequestIdFB* requestId); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrRequestSceneCaptureFB( + XrSession session, + const XrSceneCaptureRequestInfoFB* info, + XrAsyncRequestIdFB* requestId); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_FB_spatial_entity_container is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_spatial_entity_container 1 +#define XR_FB_spatial_entity_container_SPEC_VERSION 2 +#define XR_FB_SPATIAL_ENTITY_CONTAINER_EXTENSION_NAME "XR_FB_spatial_entity_container" +typedef struct XrSpaceContainerFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t uuidCapacityInput; + uint32_t uuidCountOutput; + XrUuidEXT* uuids; +} XrSpaceContainerFB; + +typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceContainerFB)(XrSession session, XrSpace space, XrSpaceContainerFB* spaceContainerOutput); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceContainerFB( + XrSession session, + XrSpace space, + XrSpaceContainerFB* spaceContainerOutput); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_META_foveation_eye_tracked is a preprocessor guard. Do not pass it to API calls. +#define XR_META_foveation_eye_tracked 1 +#define XR_FOVEATION_CENTER_SIZE_META 2 +#define XR_META_foveation_eye_tracked_SPEC_VERSION 1 +#define XR_META_FOVEATION_EYE_TRACKED_EXTENSION_NAME "XR_META_foveation_eye_tracked" +typedef XrFlags64 XrFoveationEyeTrackedProfileCreateFlagsMETA; + +// Flag bits for XrFoveationEyeTrackedProfileCreateFlagsMETA + +typedef XrFlags64 XrFoveationEyeTrackedStateFlagsMETA; + +// Flag bits for XrFoveationEyeTrackedStateFlagsMETA +static const XrFoveationEyeTrackedStateFlagsMETA XR_FOVEATION_EYE_TRACKED_STATE_VALID_BIT_META = 0x00000001; + +// XrFoveationEyeTrackedProfileCreateInfoMETA extends XrFoveationLevelProfileCreateInfoFB +typedef struct XrFoveationEyeTrackedProfileCreateInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrFoveationEyeTrackedProfileCreateFlagsMETA flags; +} XrFoveationEyeTrackedProfileCreateInfoMETA; + +typedef struct XrFoveationEyeTrackedStateMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrVector2f foveationCenter[XR_FOVEATION_CENTER_SIZE_META]; + XrFoveationEyeTrackedStateFlagsMETA flags; +} XrFoveationEyeTrackedStateMETA; + +// XrSystemFoveationEyeTrackedPropertiesMETA extends XrSystemProperties +typedef struct XrSystemFoveationEyeTrackedPropertiesMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsFoveationEyeTracked; +} XrSystemFoveationEyeTrackedPropertiesMETA; + +typedef XrResult (XRAPI_PTR *PFN_xrGetFoveationEyeTrackedStateMETA)(XrSession session, XrFoveationEyeTrackedStateMETA* foveationState); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetFoveationEyeTrackedStateMETA( + XrSession session, + XrFoveationEyeTrackedStateMETA* foveationState); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_FB_face_tracking is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_face_tracking 1 + +#define XR_FACE_EXPRESSSION_SET_DEFAULT_FB XR_FACE_EXPRESSION_SET_DEFAULT_FB + +XR_DEFINE_HANDLE(XrFaceTrackerFB) +#define XR_FB_face_tracking_SPEC_VERSION 1 +#define XR_FB_FACE_TRACKING_EXTENSION_NAME "XR_FB_face_tracking" + +typedef enum XrFaceExpressionFB { + XR_FACE_EXPRESSION_BROW_LOWERER_L_FB = 0, + XR_FACE_EXPRESSION_BROW_LOWERER_R_FB = 1, + XR_FACE_EXPRESSION_CHEEK_PUFF_L_FB = 2, + XR_FACE_EXPRESSION_CHEEK_PUFF_R_FB = 3, + XR_FACE_EXPRESSION_CHEEK_RAISER_L_FB = 4, + XR_FACE_EXPRESSION_CHEEK_RAISER_R_FB = 5, + XR_FACE_EXPRESSION_CHEEK_SUCK_L_FB = 6, + XR_FACE_EXPRESSION_CHEEK_SUCK_R_FB = 7, + XR_FACE_EXPRESSION_CHIN_RAISER_B_FB = 8, + XR_FACE_EXPRESSION_CHIN_RAISER_T_FB = 9, + XR_FACE_EXPRESSION_DIMPLER_L_FB = 10, + XR_FACE_EXPRESSION_DIMPLER_R_FB = 11, + XR_FACE_EXPRESSION_EYES_CLOSED_L_FB = 12, + XR_FACE_EXPRESSION_EYES_CLOSED_R_FB = 13, + XR_FACE_EXPRESSION_EYES_LOOK_DOWN_L_FB = 14, + XR_FACE_EXPRESSION_EYES_LOOK_DOWN_R_FB = 15, + XR_FACE_EXPRESSION_EYES_LOOK_LEFT_L_FB = 16, + XR_FACE_EXPRESSION_EYES_LOOK_LEFT_R_FB = 17, + XR_FACE_EXPRESSION_EYES_LOOK_RIGHT_L_FB = 18, + XR_FACE_EXPRESSION_EYES_LOOK_RIGHT_R_FB = 19, + XR_FACE_EXPRESSION_EYES_LOOK_UP_L_FB = 20, + XR_FACE_EXPRESSION_EYES_LOOK_UP_R_FB = 21, + XR_FACE_EXPRESSION_INNER_BROW_RAISER_L_FB = 22, + XR_FACE_EXPRESSION_INNER_BROW_RAISER_R_FB = 23, + XR_FACE_EXPRESSION_JAW_DROP_FB = 24, + XR_FACE_EXPRESSION_JAW_SIDEWAYS_LEFT_FB = 25, + XR_FACE_EXPRESSION_JAW_SIDEWAYS_RIGHT_FB = 26, + XR_FACE_EXPRESSION_JAW_THRUST_FB = 27, + XR_FACE_EXPRESSION_LID_TIGHTENER_L_FB = 28, + XR_FACE_EXPRESSION_LID_TIGHTENER_R_FB = 29, + XR_FACE_EXPRESSION_LIP_CORNER_DEPRESSOR_L_FB = 30, + XR_FACE_EXPRESSION_LIP_CORNER_DEPRESSOR_R_FB = 31, + XR_FACE_EXPRESSION_LIP_CORNER_PULLER_L_FB = 32, + XR_FACE_EXPRESSION_LIP_CORNER_PULLER_R_FB = 33, + XR_FACE_EXPRESSION_LIP_FUNNELER_LB_FB = 34, + XR_FACE_EXPRESSION_LIP_FUNNELER_LT_FB = 35, + XR_FACE_EXPRESSION_LIP_FUNNELER_RB_FB = 36, + XR_FACE_EXPRESSION_LIP_FUNNELER_RT_FB = 37, + XR_FACE_EXPRESSION_LIP_PRESSOR_L_FB = 38, + XR_FACE_EXPRESSION_LIP_PRESSOR_R_FB = 39, + XR_FACE_EXPRESSION_LIP_PUCKER_L_FB = 40, + XR_FACE_EXPRESSION_LIP_PUCKER_R_FB = 41, + XR_FACE_EXPRESSION_LIP_STRETCHER_L_FB = 42, + XR_FACE_EXPRESSION_LIP_STRETCHER_R_FB = 43, + XR_FACE_EXPRESSION_LIP_SUCK_LB_FB = 44, + XR_FACE_EXPRESSION_LIP_SUCK_LT_FB = 45, + XR_FACE_EXPRESSION_LIP_SUCK_RB_FB = 46, + XR_FACE_EXPRESSION_LIP_SUCK_RT_FB = 47, + XR_FACE_EXPRESSION_LIP_TIGHTENER_L_FB = 48, + XR_FACE_EXPRESSION_LIP_TIGHTENER_R_FB = 49, + XR_FACE_EXPRESSION_LIPS_TOWARD_FB = 50, + XR_FACE_EXPRESSION_LOWER_LIP_DEPRESSOR_L_FB = 51, + XR_FACE_EXPRESSION_LOWER_LIP_DEPRESSOR_R_FB = 52, + XR_FACE_EXPRESSION_MOUTH_LEFT_FB = 53, + XR_FACE_EXPRESSION_MOUTH_RIGHT_FB = 54, + XR_FACE_EXPRESSION_NOSE_WRINKLER_L_FB = 55, + XR_FACE_EXPRESSION_NOSE_WRINKLER_R_FB = 56, + XR_FACE_EXPRESSION_OUTER_BROW_RAISER_L_FB = 57, + XR_FACE_EXPRESSION_OUTER_BROW_RAISER_R_FB = 58, + XR_FACE_EXPRESSION_UPPER_LID_RAISER_L_FB = 59, + XR_FACE_EXPRESSION_UPPER_LID_RAISER_R_FB = 60, + XR_FACE_EXPRESSION_UPPER_LIP_RAISER_L_FB = 61, + XR_FACE_EXPRESSION_UPPER_LIP_RAISER_R_FB = 62, + XR_FACE_EXPRESSION_COUNT_FB = 63, + XR_FACE_EXPRESSION_MAX_ENUM_FB = 0x7FFFFFFF +} XrFaceExpressionFB; + +typedef enum XrFaceExpressionSetFB { + XR_FACE_EXPRESSION_SET_DEFAULT_FB = 0, + XR_FACE_EXPRESSION_SET_MAX_ENUM_FB = 0x7FFFFFFF +} XrFaceExpressionSetFB; + +typedef enum XrFaceConfidenceFB { + XR_FACE_CONFIDENCE_LOWER_FACE_FB = 0, + XR_FACE_CONFIDENCE_UPPER_FACE_FB = 1, + XR_FACE_CONFIDENCE_COUNT_FB = 2, + XR_FACE_CONFIDENCE_MAX_ENUM_FB = 0x7FFFFFFF +} XrFaceConfidenceFB; +// XrSystemFaceTrackingPropertiesFB extends XrSystemProperties +typedef struct XrSystemFaceTrackingPropertiesFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsFaceTracking; +} XrSystemFaceTrackingPropertiesFB; + +typedef struct XrFaceTrackerCreateInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrFaceExpressionSetFB faceExpressionSet; +} XrFaceTrackerCreateInfoFB; + +typedef struct XrFaceExpressionInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrTime time; +} XrFaceExpressionInfoFB; + +typedef struct XrFaceExpressionStatusFB { + XrBool32 isValid; + XrBool32 isEyeFollowingBlendshapesValid; +} XrFaceExpressionStatusFB; + +typedef struct XrFaceExpressionWeightsFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t weightCount; + float* weights; + uint32_t confidenceCount; + float* confidences; + XrFaceExpressionStatusFB status; + XrTime time; +} XrFaceExpressionWeightsFB; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateFaceTrackerFB)(XrSession session, const XrFaceTrackerCreateInfoFB* createInfo, XrFaceTrackerFB* faceTracker); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyFaceTrackerFB)(XrFaceTrackerFB faceTracker); +typedef XrResult (XRAPI_PTR *PFN_xrGetFaceExpressionWeightsFB)(XrFaceTrackerFB faceTracker, const XrFaceExpressionInfoFB* expressionInfo, XrFaceExpressionWeightsFB* expressionWeights); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateFaceTrackerFB( + XrSession session, + const XrFaceTrackerCreateInfoFB* createInfo, + XrFaceTrackerFB* faceTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyFaceTrackerFB( + XrFaceTrackerFB faceTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetFaceExpressionWeightsFB( + XrFaceTrackerFB faceTracker, + const XrFaceExpressionInfoFB* expressionInfo, + XrFaceExpressionWeightsFB* expressionWeights); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_FB_eye_tracking_social is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_eye_tracking_social 1 +XR_DEFINE_HANDLE(XrEyeTrackerFB) +#define XR_FB_eye_tracking_social_SPEC_VERSION 1 +#define XR_FB_EYE_TRACKING_SOCIAL_EXTENSION_NAME "XR_FB_eye_tracking_social" + +typedef enum XrEyePositionFB { + XR_EYE_POSITION_LEFT_FB = 0, + XR_EYE_POSITION_RIGHT_FB = 1, + XR_EYE_POSITION_COUNT_FB = 2, + XR_EYE_POSITION_MAX_ENUM_FB = 0x7FFFFFFF +} XrEyePositionFB; +typedef struct XrEyeGazeFB { + XrBool32 isValid; + XrPosef gazePose; + float gazeConfidence; +} XrEyeGazeFB; + +typedef struct XrEyeTrackerCreateInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrEyeTrackerCreateInfoFB; + +typedef struct XrEyeGazesInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace baseSpace; + XrTime time; +} XrEyeGazesInfoFB; + +// XrSystemEyeTrackingPropertiesFB extends XrSystemProperties +typedef struct XrSystemEyeTrackingPropertiesFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsEyeTracking; +} XrSystemEyeTrackingPropertiesFB; + +typedef struct XrEyeGazesFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrEyeGazeFB gaze[XR_EYE_POSITION_COUNT_FB]; + XrTime time; +} XrEyeGazesFB; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateEyeTrackerFB)(XrSession session, const XrEyeTrackerCreateInfoFB* createInfo, XrEyeTrackerFB* eyeTracker); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyEyeTrackerFB)(XrEyeTrackerFB eyeTracker); +typedef XrResult (XRAPI_PTR *PFN_xrGetEyeGazesFB)(XrEyeTrackerFB eyeTracker, const XrEyeGazesInfoFB* gazeInfo, XrEyeGazesFB* eyeGazes); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateEyeTrackerFB( + XrSession session, + const XrEyeTrackerCreateInfoFB* createInfo, + XrEyeTrackerFB* eyeTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyEyeTrackerFB( + XrEyeTrackerFB eyeTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetEyeGazesFB( + XrEyeTrackerFB eyeTracker, + const XrEyeGazesInfoFB* gazeInfo, + XrEyeGazesFB* eyeGazes); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_FB_passthrough_keyboard_hands is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_passthrough_keyboard_hands 1 +#define XR_FB_passthrough_keyboard_hands_SPEC_VERSION 2 +#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 */ + + +// XR_FB_composition_layer_settings is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_composition_layer_settings 1 +#define XR_FB_composition_layer_settings_SPEC_VERSION 1 +#define XR_FB_COMPOSITION_LAYER_SETTINGS_EXTENSION_NAME "XR_FB_composition_layer_settings" +typedef XrFlags64 XrCompositionLayerSettingsFlagsFB; + +// Flag bits for XrCompositionLayerSettingsFlagsFB +static const XrCompositionLayerSettingsFlagsFB XR_COMPOSITION_LAYER_SETTINGS_NORMAL_SUPER_SAMPLING_BIT_FB = 0x00000001; +static const XrCompositionLayerSettingsFlagsFB XR_COMPOSITION_LAYER_SETTINGS_QUALITY_SUPER_SAMPLING_BIT_FB = 0x00000002; +static const XrCompositionLayerSettingsFlagsFB XR_COMPOSITION_LAYER_SETTINGS_NORMAL_SHARPENING_BIT_FB = 0x00000004; +static const XrCompositionLayerSettingsFlagsFB XR_COMPOSITION_LAYER_SETTINGS_QUALITY_SHARPENING_BIT_FB = 0x00000008; +static const XrCompositionLayerSettingsFlagsFB XR_COMPOSITION_LAYER_SETTINGS_AUTO_LAYER_FILTER_BIT_META = 0x00000020; + +// XrCompositionLayerSettingsFB extends XrCompositionLayerBaseHeader +typedef struct XrCompositionLayerSettingsFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCompositionLayerSettingsFlagsFB layerFlags; +} XrCompositionLayerSettingsFB; + + + +// XR_FB_touch_controller_proximity is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_touch_controller_proximity 1 +#define XR_FB_touch_controller_proximity_SPEC_VERSION 1 +#define XR_FB_TOUCH_CONTROLLER_PROXIMITY_EXTENSION_NAME "XR_FB_touch_controller_proximity" + + +// XR_FB_haptic_pcm is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_haptic_pcm 1 + +#define XR_MAX_HAPTIC_PCM_BUFFER_SIZE_FB 4000 + +#define XR_FB_haptic_pcm_SPEC_VERSION 1 +#define XR_FB_HAPTIC_PCM_EXTENSION_NAME "XR_FB_haptic_pcm" +typedef struct XrHapticPcmVibrationFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t bufferSize; + const float* buffer; + float sampleRate; + XrBool32 append; + uint32_t* samplesConsumed; +} XrHapticPcmVibrationFB; + +typedef struct XrDevicePcmSampleRateStateFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + float sampleRate; +} XrDevicePcmSampleRateStateFB; + +typedef XrDevicePcmSampleRateStateFB XrDevicePcmSampleRateGetInfoFB; + +typedef XrResult (XRAPI_PTR *PFN_xrGetDeviceSampleRateFB)(XrSession session, const XrHapticActionInfo* hapticActionInfo, XrDevicePcmSampleRateGetInfoFB* deviceSampleRate); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetDeviceSampleRateFB( + XrSession session, + const XrHapticActionInfo* hapticActionInfo, + XrDevicePcmSampleRateGetInfoFB* deviceSampleRate); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_EXT_frame_synthesis is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_frame_synthesis 1 +#define XR_EXT_frame_synthesis_SPEC_VERSION 1 +#define XR_EXT_FRAME_SYNTHESIS_EXTENSION_NAME "XR_EXT_frame_synthesis" +typedef XrFlags64 XrFrameSynthesisInfoFlagsEXT; + +// Flag bits for XrFrameSynthesisInfoFlagsEXT +static const XrFrameSynthesisInfoFlagsEXT XR_FRAME_SYNTHESIS_INFO_USE_2D_MOTION_VECTOR_BIT_EXT = 0x00000001; +static const XrFrameSynthesisInfoFlagsEXT XR_FRAME_SYNTHESIS_INFO_REQUEST_RELAXED_FRAME_INTERVAL_BIT_EXT = 0x00000002; + +// XrFrameSynthesisInfoEXT extends XrCompositionLayerProjectionView +typedef struct XrFrameSynthesisInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrFrameSynthesisInfoFlagsEXT layerFlags; + XrSwapchainSubImage motionVectorSubImage; + XrVector4f motionVectorScale; + XrVector4f motionVectorOffset; + XrPosef appSpaceDeltaPose; + XrSwapchainSubImage depthSubImage; + float minDepth; + float maxDepth; + float nearZ; + float farZ; +} XrFrameSynthesisInfoEXT; + +// XrFrameSynthesisConfigViewEXT extends XrViewConfigurationView +typedef struct XrFrameSynthesisConfigViewEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t recommendedMotionVectorImageRectWidth; + uint32_t recommendedMotionVectorImageRectHeight; +} XrFrameSynthesisConfigViewEXT; + + + +// XR_FB_composition_layer_depth_test is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_composition_layer_depth_test 1 +#define XR_FB_composition_layer_depth_test_SPEC_VERSION 1 +#define XR_FB_COMPOSITION_LAYER_DEPTH_TEST_EXTENSION_NAME "XR_FB_composition_layer_depth_test" + +typedef enum XrCompareOpFB { + XR_COMPARE_OP_NEVER_FB = 0, + XR_COMPARE_OP_LESS_FB = 1, + XR_COMPARE_OP_EQUAL_FB = 2, + XR_COMPARE_OP_LESS_OR_EQUAL_FB = 3, + XR_COMPARE_OP_GREATER_FB = 4, + XR_COMPARE_OP_NOT_EQUAL_FB = 5, + XR_COMPARE_OP_GREATER_OR_EQUAL_FB = 6, + XR_COMPARE_OP_ALWAYS_FB = 7, + XR_COMPARE_OP_MAX_ENUM_FB = 0x7FFFFFFF +} XrCompareOpFB; +// XrCompositionLayerDepthTestFB extends XrCompositionLayerBaseHeader +typedef struct XrCompositionLayerDepthTestFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 depthMask; + XrCompareOpFB compareOp; +} XrCompositionLayerDepthTestFB; + + + +// XR_META_local_dimming is a preprocessor guard. Do not pass it to API calls. +#define XR_META_local_dimming 1 +#define XR_META_local_dimming_SPEC_VERSION 1 +#define XR_META_LOCAL_DIMMING_EXTENSION_NAME "XR_META_local_dimming" + +typedef enum XrLocalDimmingModeMETA { + XR_LOCAL_DIMMING_MODE_OFF_META = 0, + XR_LOCAL_DIMMING_MODE_ON_META = 1, + XR_LOCAL_DIMMING_MODE_MAX_ENUM_META = 0x7FFFFFFF +} XrLocalDimmingModeMETA; +// XrLocalDimmingFrameEndInfoMETA extends XrFrameEndInfo +typedef struct XrLocalDimmingFrameEndInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrLocalDimmingModeMETA localDimmingMode; +} XrLocalDimmingFrameEndInfoMETA; + + + +// XR_META_passthrough_preferences is a preprocessor guard. Do not pass it to API calls. +#define XR_META_passthrough_preferences 1 +#define XR_META_passthrough_preferences_SPEC_VERSION 1 +#define XR_META_PASSTHROUGH_PREFERENCES_EXTENSION_NAME "XR_META_passthrough_preferences" +typedef XrFlags64 XrPassthroughPreferenceFlagsMETA; + +// Flag bits for XrPassthroughPreferenceFlagsMETA +static const XrPassthroughPreferenceFlagsMETA XR_PASSTHROUGH_PREFERENCE_DEFAULT_TO_ACTIVE_BIT_META = 0x00000001; + +typedef struct XrPassthroughPreferencesMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPassthroughPreferenceFlagsMETA flags; +} XrPassthroughPreferencesMETA; + +typedef XrResult (XRAPI_PTR *PFN_xrGetPassthroughPreferencesMETA)(XrSession session, XrPassthroughPreferencesMETA* preferences); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetPassthroughPreferencesMETA( + XrSession session, + XrPassthroughPreferencesMETA* preferences); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_META_virtual_keyboard is a preprocessor guard. Do not pass it to API calls. +#define XR_META_virtual_keyboard 1 +XR_DEFINE_HANDLE(XrVirtualKeyboardMETA) +#define XR_MAX_VIRTUAL_KEYBOARD_COMMIT_TEXT_SIZE_META 3992 +#define XR_META_virtual_keyboard_SPEC_VERSION 1 +#define XR_META_VIRTUAL_KEYBOARD_EXTENSION_NAME "XR_META_virtual_keyboard" + +typedef enum XrVirtualKeyboardLocationTypeMETA { + XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_CUSTOM_META = 0, + XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_FAR_META = 1, + XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_DIRECT_META = 2, + XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_MAX_ENUM_META = 0x7FFFFFFF +} XrVirtualKeyboardLocationTypeMETA; + +typedef enum XrVirtualKeyboardInputSourceMETA { + XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_RAY_LEFT_META = 1, + XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_RAY_RIGHT_META = 2, + XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_RAY_LEFT_META = 3, + XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_RAY_RIGHT_META = 4, + XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_DIRECT_LEFT_META = 5, + XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_DIRECT_RIGHT_META = 6, + XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_DIRECT_INDEX_TIP_LEFT_META = 7, + XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_DIRECT_INDEX_TIP_RIGHT_META = 8, + XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_MAX_ENUM_META = 0x7FFFFFFF +} XrVirtualKeyboardInputSourceMETA; +typedef XrFlags64 XrVirtualKeyboardInputStateFlagsMETA; + +// Flag bits for XrVirtualKeyboardInputStateFlagsMETA +static const XrVirtualKeyboardInputStateFlagsMETA XR_VIRTUAL_KEYBOARD_INPUT_STATE_PRESSED_BIT_META = 0x00000001; + +// XrSystemVirtualKeyboardPropertiesMETA extends XrSystemProperties +typedef struct XrSystemVirtualKeyboardPropertiesMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsVirtualKeyboard; +} XrSystemVirtualKeyboardPropertiesMETA; + +typedef struct XrVirtualKeyboardCreateInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrVirtualKeyboardCreateInfoMETA; + +typedef struct XrVirtualKeyboardSpaceCreateInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrVirtualKeyboardLocationTypeMETA locationType; + XrSpace space; + XrPosef poseInSpace; +} XrVirtualKeyboardSpaceCreateInfoMETA; + +typedef struct XrVirtualKeyboardLocationInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrVirtualKeyboardLocationTypeMETA locationType; + XrSpace space; + XrPosef poseInSpace; + float scale; +} XrVirtualKeyboardLocationInfoMETA; + +typedef struct XrVirtualKeyboardModelVisibilitySetInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 visible; +} XrVirtualKeyboardModelVisibilitySetInfoMETA; + +typedef struct XrVirtualKeyboardAnimationStateMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + int32_t animationIndex; + float fraction; +} XrVirtualKeyboardAnimationStateMETA; + +typedef struct XrVirtualKeyboardModelAnimationStatesMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t stateCapacityInput; + uint32_t stateCountOutput; + XrVirtualKeyboardAnimationStateMETA* states; +} XrVirtualKeyboardModelAnimationStatesMETA; + +typedef struct XrVirtualKeyboardTextureDataMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t textureWidth; + uint32_t textureHeight; + uint32_t bufferCapacityInput; + uint32_t bufferCountOutput; + uint8_t* buffer; +} XrVirtualKeyboardTextureDataMETA; + +typedef struct XrVirtualKeyboardInputInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrVirtualKeyboardInputSourceMETA inputSource; + XrSpace inputSpace; + XrPosef inputPoseInSpace; + XrVirtualKeyboardInputStateFlagsMETA inputState; +} XrVirtualKeyboardInputInfoMETA; + +typedef struct XrVirtualKeyboardTextContextChangeInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + const char* textContext; +} XrVirtualKeyboardTextContextChangeInfoMETA; + +typedef struct XrEventDataVirtualKeyboardCommitTextMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrVirtualKeyboardMETA keyboard; + char text[XR_MAX_VIRTUAL_KEYBOARD_COMMIT_TEXT_SIZE_META]; +} XrEventDataVirtualKeyboardCommitTextMETA; + +typedef struct XrEventDataVirtualKeyboardBackspaceMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrVirtualKeyboardMETA keyboard; +} XrEventDataVirtualKeyboardBackspaceMETA; + +typedef struct XrEventDataVirtualKeyboardEnterMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrVirtualKeyboardMETA keyboard; +} XrEventDataVirtualKeyboardEnterMETA; + +typedef struct XrEventDataVirtualKeyboardShownMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrVirtualKeyboardMETA keyboard; +} XrEventDataVirtualKeyboardShownMETA; + +typedef struct XrEventDataVirtualKeyboardHiddenMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrVirtualKeyboardMETA keyboard; +} XrEventDataVirtualKeyboardHiddenMETA; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateVirtualKeyboardMETA)(XrSession session, const XrVirtualKeyboardCreateInfoMETA* createInfo, XrVirtualKeyboardMETA* keyboard); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyVirtualKeyboardMETA)(XrVirtualKeyboardMETA keyboard); +typedef XrResult (XRAPI_PTR *PFN_xrCreateVirtualKeyboardSpaceMETA)(XrSession session, XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardSpaceCreateInfoMETA* createInfo, XrSpace* keyboardSpace); +typedef XrResult (XRAPI_PTR *PFN_xrSuggestVirtualKeyboardLocationMETA)(XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardLocationInfoMETA* locationInfo); +typedef XrResult (XRAPI_PTR *PFN_xrGetVirtualKeyboardScaleMETA)(XrVirtualKeyboardMETA keyboard, float* scale); +typedef XrResult (XRAPI_PTR *PFN_xrSetVirtualKeyboardModelVisibilityMETA)(XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardModelVisibilitySetInfoMETA* modelVisibility); +typedef XrResult (XRAPI_PTR *PFN_xrGetVirtualKeyboardModelAnimationStatesMETA)(XrVirtualKeyboardMETA keyboard, XrVirtualKeyboardModelAnimationStatesMETA* animationStates); +typedef XrResult (XRAPI_PTR *PFN_xrGetVirtualKeyboardDirtyTexturesMETA)(XrVirtualKeyboardMETA keyboard, uint32_t textureIdCapacityInput, uint32_t* textureIdCountOutput, uint64_t* textureIds); +typedef XrResult (XRAPI_PTR *PFN_xrGetVirtualKeyboardTextureDataMETA)(XrVirtualKeyboardMETA keyboard, uint64_t textureId, XrVirtualKeyboardTextureDataMETA* textureData); +typedef XrResult (XRAPI_PTR *PFN_xrSendVirtualKeyboardInputMETA)(XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardInputInfoMETA* info, XrPosef* interactorRootPose); +typedef XrResult (XRAPI_PTR *PFN_xrChangeVirtualKeyboardTextContextMETA)(XrVirtualKeyboardMETA keyboard, const XrVirtualKeyboardTextContextChangeInfoMETA* changeInfo); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateVirtualKeyboardMETA( + XrSession session, + const XrVirtualKeyboardCreateInfoMETA* createInfo, + XrVirtualKeyboardMETA* keyboard); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyVirtualKeyboardMETA( + XrVirtualKeyboardMETA keyboard); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateVirtualKeyboardSpaceMETA( + XrSession session, + XrVirtualKeyboardMETA keyboard, + const XrVirtualKeyboardSpaceCreateInfoMETA* createInfo, + XrSpace* keyboardSpace); + +XRAPI_ATTR XrResult XRAPI_CALL xrSuggestVirtualKeyboardLocationMETA( + XrVirtualKeyboardMETA keyboard, + const XrVirtualKeyboardLocationInfoMETA* locationInfo); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetVirtualKeyboardScaleMETA( + XrVirtualKeyboardMETA keyboard, + float* scale); + +XRAPI_ATTR XrResult XRAPI_CALL xrSetVirtualKeyboardModelVisibilityMETA( + XrVirtualKeyboardMETA keyboard, + const XrVirtualKeyboardModelVisibilitySetInfoMETA* modelVisibility); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetVirtualKeyboardModelAnimationStatesMETA( + XrVirtualKeyboardMETA keyboard, + XrVirtualKeyboardModelAnimationStatesMETA* animationStates); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetVirtualKeyboardDirtyTexturesMETA( + XrVirtualKeyboardMETA keyboard, + uint32_t textureIdCapacityInput, + uint32_t* textureIdCountOutput, + uint64_t* textureIds); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetVirtualKeyboardTextureDataMETA( + XrVirtualKeyboardMETA keyboard, + uint64_t textureId, + XrVirtualKeyboardTextureDataMETA* textureData); + +XRAPI_ATTR XrResult XRAPI_CALL xrSendVirtualKeyboardInputMETA( + XrVirtualKeyboardMETA keyboard, + const XrVirtualKeyboardInputInfoMETA* info, + XrPosef* interactorRootPose); + +XRAPI_ATTR XrResult XRAPI_CALL xrChangeVirtualKeyboardTextContextMETA( + XrVirtualKeyboardMETA keyboard, + const XrVirtualKeyboardTextContextChangeInfoMETA* changeInfo); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_OCULUS_external_camera is a preprocessor guard. Do not pass it to API calls. +#define XR_OCULUS_external_camera 1 +#define XR_MAX_EXTERNAL_CAMERA_NAME_SIZE_OCULUS 32 +#define XR_OCULUS_external_camera_SPEC_VERSION 1 +#define XR_OCULUS_EXTERNAL_CAMERA_EXTENSION_NAME "XR_OCULUS_external_camera" + +typedef enum XrExternalCameraAttachedToDeviceOCULUS { + XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_NONE_OCULUS = 0, + XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_HMD_OCULUS = 1, + XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_LTOUCH_OCULUS = 2, + XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_RTOUCH_OCULUS = 3, + XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_MAX_ENUM_OCULUS = 0x7FFFFFFF +} XrExternalCameraAttachedToDeviceOCULUS; +typedef XrFlags64 XrExternalCameraStatusFlagsOCULUS; + +// Flag bits for XrExternalCameraStatusFlagsOCULUS +static const XrExternalCameraStatusFlagsOCULUS XR_EXTERNAL_CAMERA_STATUS_CONNECTED_BIT_OCULUS = 0x00000001; +static const XrExternalCameraStatusFlagsOCULUS XR_EXTERNAL_CAMERA_STATUS_CALIBRATING_BIT_OCULUS = 0x00000002; +static const XrExternalCameraStatusFlagsOCULUS XR_EXTERNAL_CAMERA_STATUS_CALIBRATION_FAILED_BIT_OCULUS = 0x00000004; +static const XrExternalCameraStatusFlagsOCULUS XR_EXTERNAL_CAMERA_STATUS_CALIBRATED_BIT_OCULUS = 0x00000008; +static const XrExternalCameraStatusFlagsOCULUS XR_EXTERNAL_CAMERA_STATUS_CAPTURING_BIT_OCULUS = 0x00000010; + +typedef struct XrExternalCameraIntrinsicsOCULUS { + XrTime lastChangeTime; + XrFovf fov; + float virtualNearPlaneDistance; + float virtualFarPlaneDistance; + XrExtent2Di imageSensorPixelResolution; +} XrExternalCameraIntrinsicsOCULUS; + +typedef struct XrExternalCameraExtrinsicsOCULUS { + XrTime lastChangeTime; + XrExternalCameraStatusFlagsOCULUS cameraStatusFlags; + XrExternalCameraAttachedToDeviceOCULUS attachedToDevice; + XrPosef relativePose; +} XrExternalCameraExtrinsicsOCULUS; + +typedef struct XrExternalCameraOCULUS { + XrStructureType type; + const void* XR_MAY_ALIAS next; + char name[XR_MAX_EXTERNAL_CAMERA_NAME_SIZE_OCULUS]; + XrExternalCameraIntrinsicsOCULUS intrinsics; + XrExternalCameraExtrinsicsOCULUS extrinsics; +} XrExternalCameraOCULUS; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateExternalCamerasOCULUS)(XrSession session, uint32_t cameraCapacityInput, uint32_t* cameraCountOutput, XrExternalCameraOCULUS* cameras); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateExternalCamerasOCULUS( + XrSession session, + uint32_t cameraCapacityInput, + uint32_t* cameraCountOutput, + XrExternalCameraOCULUS* cameras); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_META_performance_metrics is a preprocessor guard. Do not pass it to API calls. +#define XR_META_performance_metrics 1 +#define XR_META_performance_metrics_SPEC_VERSION 2 +#define XR_META_PERFORMANCE_METRICS_EXTENSION_NAME "XR_META_performance_metrics" + +typedef enum XrPerformanceMetricsCounterUnitMETA { + XR_PERFORMANCE_METRICS_COUNTER_UNIT_GENERIC_META = 0, + XR_PERFORMANCE_METRICS_COUNTER_UNIT_PERCENTAGE_META = 1, + XR_PERFORMANCE_METRICS_COUNTER_UNIT_MILLISECONDS_META = 2, + XR_PERFORMANCE_METRICS_COUNTER_UNIT_BYTES_META = 3, + XR_PERFORMANCE_METRICS_COUNTER_UNIT_HERTZ_META = 4, + XR_PERFORMANCE_METRICS_COUNTER_UNIT_MAX_ENUM_META = 0x7FFFFFFF +} XrPerformanceMetricsCounterUnitMETA; +typedef XrFlags64 XrPerformanceMetricsCounterFlagsMETA; + +// Flag bits for XrPerformanceMetricsCounterFlagsMETA +static const XrPerformanceMetricsCounterFlagsMETA XR_PERFORMANCE_METRICS_COUNTER_ANY_VALUE_VALID_BIT_META = 0x00000001; +static const XrPerformanceMetricsCounterFlagsMETA XR_PERFORMANCE_METRICS_COUNTER_UINT_VALUE_VALID_BIT_META = 0x00000002; +static const XrPerformanceMetricsCounterFlagsMETA XR_PERFORMANCE_METRICS_COUNTER_FLOAT_VALUE_VALID_BIT_META = 0x00000004; + +typedef struct XrPerformanceMetricsStateMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 enabled; +} XrPerformanceMetricsStateMETA; + +typedef struct XrPerformanceMetricsCounterMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPerformanceMetricsCounterFlagsMETA counterFlags; + XrPerformanceMetricsCounterUnitMETA counterUnit; + uint32_t uintValue; + float floatValue; +} XrPerformanceMetricsCounterMETA; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumeratePerformanceMetricsCounterPathsMETA)(XrInstance instance, uint32_t counterPathCapacityInput, uint32_t* counterPathCountOutput, XrPath* counterPaths); +typedef XrResult (XRAPI_PTR *PFN_xrSetPerformanceMetricsStateMETA)(XrSession session, const XrPerformanceMetricsStateMETA* state); +typedef XrResult (XRAPI_PTR *PFN_xrGetPerformanceMetricsStateMETA)(XrSession session, XrPerformanceMetricsStateMETA* state); +typedef XrResult (XRAPI_PTR *PFN_xrQueryPerformanceMetricsCounterMETA)(XrSession session, XrPath counterPath, XrPerformanceMetricsCounterMETA* counter); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumeratePerformanceMetricsCounterPathsMETA( + XrInstance instance, + uint32_t counterPathCapacityInput, + uint32_t* counterPathCountOutput, + XrPath* counterPaths); + +XRAPI_ATTR XrResult XRAPI_CALL xrSetPerformanceMetricsStateMETA( + XrSession session, + const XrPerformanceMetricsStateMETA* state); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetPerformanceMetricsStateMETA( + XrSession session, + XrPerformanceMetricsStateMETA* state); + +XRAPI_ATTR XrResult XRAPI_CALL xrQueryPerformanceMetricsCounterMETA( + XrSession session, + XrPath counterPath, + XrPerformanceMetricsCounterMETA* counter); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_FB_spatial_entity_storage_batch is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_spatial_entity_storage_batch 1 +#define XR_FB_spatial_entity_storage_batch_SPEC_VERSION 1 +#define XR_FB_SPATIAL_ENTITY_STORAGE_BATCH_EXTENSION_NAME "XR_FB_spatial_entity_storage_batch" +typedef struct XrSpaceListSaveInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t spaceCount; + XrSpace* spaces; + XrSpaceStorageLocationFB location; +} XrSpaceListSaveInfoFB; + +typedef struct XrEventDataSpaceListSaveCompleteFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAsyncRequestIdFB requestId; + XrResult result; +} XrEventDataSpaceListSaveCompleteFB; + +typedef XrResult (XRAPI_PTR *PFN_xrSaveSpaceListFB)(XrSession session, const XrSpaceListSaveInfoFB* info, XrAsyncRequestIdFB* requestId); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrSaveSpaceListFB( + XrSession session, + const XrSpaceListSaveInfoFB* info, + XrAsyncRequestIdFB* requestId); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_META_detached_controllers is a preprocessor guard. Do not pass it to API calls. +#define XR_META_detached_controllers 1 +#define XR_META_detached_controllers_SPEC_VERSION 1 +#define XR_META_DETACHED_CONTROLLERS_EXTENSION_NAME "XR_META_detached_controllers" + + +// XR_FB_spatial_entity_user is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_spatial_entity_user 1 +typedef uint64_t XrSpaceUserIdFB; +#define XR_FB_spatial_entity_user_SPEC_VERSION 1 +#define XR_FB_SPATIAL_ENTITY_USER_EXTENSION_NAME "XR_FB_spatial_entity_user" +typedef struct XrSpaceUserCreateInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpaceUserIdFB userId; +} XrSpaceUserCreateInfoFB; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpaceUserFB)(XrSession session, const XrSpaceUserCreateInfoFB* info, XrSpaceUserFB* user); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceUserIdFB)(XrSpaceUserFB user, XrSpaceUserIdFB* userId); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySpaceUserFB)(XrSpaceUserFB user); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpaceUserFB( + XrSession session, + const XrSpaceUserCreateInfoFB* info, + XrSpaceUserFB* user); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceUserIdFB( + XrSpaceUserFB user, + XrSpaceUserIdFB* userId); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpaceUserFB( + XrSpaceUserFB user); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_META_headset_id is a preprocessor guard. Do not pass it to API calls. +#define XR_META_headset_id 1 +#define XR_META_headset_id_SPEC_VERSION 2 +#define XR_META_HEADSET_ID_EXTENSION_NAME "XR_META_headset_id" +// XrSystemHeadsetIdPropertiesMETA extends XrSystemProperties +typedef struct XrSystemHeadsetIdPropertiesMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrUuidEXT id; +} XrSystemHeadsetIdPropertiesMETA; + + + +// XR_META_spatial_entity_discovery is a preprocessor guard. Do not pass it to API calls. +#define XR_META_spatial_entity_discovery 1 +#define XR_META_spatial_entity_discovery_SPEC_VERSION 1 +#define XR_META_SPATIAL_ENTITY_DISCOVERY_EXTENSION_NAME "XR_META_spatial_entity_discovery" +// XrSystemSpaceDiscoveryPropertiesMETA extends XrSystemProperties +typedef struct XrSystemSpaceDiscoveryPropertiesMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 supportsSpaceDiscovery; +} XrSystemSpaceDiscoveryPropertiesMETA; + +typedef struct XR_MAY_ALIAS XrSpaceFilterBaseHeaderMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrSpaceFilterBaseHeaderMETA; + +typedef struct XrSpaceDiscoveryInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t filterCount; + const XrSpaceFilterBaseHeaderMETA* const * filters; +} XrSpaceDiscoveryInfoMETA; + +typedef struct XrSpaceFilterUuidMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t uuidCount; + const XrUuidEXT* uuids; +} XrSpaceFilterUuidMETA; + +typedef struct XrSpaceFilterComponentMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpaceComponentTypeFB componentType; +} XrSpaceFilterComponentMETA; + +typedef struct XrSpaceDiscoveryResultMETA { + XrSpace space; + XrUuidEXT uuid; +} XrSpaceDiscoveryResultMETA; + +typedef struct XrSpaceDiscoveryResultsMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t resultCapacityInput; + uint32_t resultCountOutput; + XrSpaceDiscoveryResultMETA* results; +} XrSpaceDiscoveryResultsMETA; + +typedef struct XrEventDataSpaceDiscoveryResultsAvailableMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAsyncRequestIdFB requestId; +} XrEventDataSpaceDiscoveryResultsAvailableMETA; + +typedef struct XrEventDataSpaceDiscoveryCompleteMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAsyncRequestIdFB requestId; + XrResult result; +} XrEventDataSpaceDiscoveryCompleteMETA; + +typedef XrResult (XRAPI_PTR *PFN_xrDiscoverSpacesMETA)(XrSession session, const XrSpaceDiscoveryInfoMETA* info, XrAsyncRequestIdFB* requestId); +typedef XrResult (XRAPI_PTR *PFN_xrRetrieveSpaceDiscoveryResultsMETA)(XrSession session, XrAsyncRequestIdFB requestId, XrSpaceDiscoveryResultsMETA* results); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrDiscoverSpacesMETA( + XrSession session, + const XrSpaceDiscoveryInfoMETA* info, + XrAsyncRequestIdFB* requestId); + +XRAPI_ATTR XrResult XRAPI_CALL xrRetrieveSpaceDiscoveryResultsMETA( + XrSession session, + XrAsyncRequestIdFB requestId, + XrSpaceDiscoveryResultsMETA* results); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_META_hand_tracking_microgestures is a preprocessor guard. Do not pass it to API calls. +#define XR_META_hand_tracking_microgestures 1 +#define XR_META_hand_tracking_microgestures_SPEC_VERSION 1 +#define XR_META_HAND_TRACKING_MICROGESTURES_EXTENSION_NAME "XR_META_hand_tracking_microgestures" + + +// XR_META_recommended_layer_resolution is a preprocessor guard. Do not pass it to API calls. +#define XR_META_recommended_layer_resolution 1 +#define XR_META_recommended_layer_resolution_SPEC_VERSION 1 +#define XR_META_RECOMMENDED_LAYER_RESOLUTION_EXTENSION_NAME "XR_META_recommended_layer_resolution" +typedef struct XrRecommendedLayerResolutionMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrExtent2Di recommendedImageDimensions; + XrBool32 isValid; +} XrRecommendedLayerResolutionMETA; + +typedef struct XrRecommendedLayerResolutionGetInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + const XrCompositionLayerBaseHeader* layer; + XrTime predictedDisplayTime; +} XrRecommendedLayerResolutionGetInfoMETA; + +typedef XrResult (XRAPI_PTR *PFN_xrGetRecommendedLayerResolutionMETA)(XrSession session, const XrRecommendedLayerResolutionGetInfoMETA* info, XrRecommendedLayerResolutionMETA* resolution); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetRecommendedLayerResolutionMETA( + XrSession session, + const XrRecommendedLayerResolutionGetInfoMETA* info, + XrRecommendedLayerResolutionMETA* resolution); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_META_spatial_entity_persistence is a preprocessor guard. Do not pass it to API calls. +#define XR_META_spatial_entity_persistence 1 +#define XR_META_spatial_entity_persistence_SPEC_VERSION 1 +#define XR_META_SPATIAL_ENTITY_PERSISTENCE_EXTENSION_NAME "XR_META_spatial_entity_persistence" +// XrSystemSpacePersistencePropertiesMETA extends XrSystemProperties +typedef struct XrSystemSpacePersistencePropertiesMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 supportsSpacePersistence; +} XrSystemSpacePersistencePropertiesMETA; + +typedef struct XrSpacesSaveInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t spaceCount; + XrSpace* spaces; +} XrSpacesSaveInfoMETA; + +typedef struct XrEventDataSpacesSaveResultMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAsyncRequestIdFB requestId; + XrResult result; +} XrEventDataSpacesSaveResultMETA; + +typedef struct XrSpacesEraseInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t spaceCount; + XrSpace* spaces; + uint32_t uuidCount; + XrUuidEXT* uuids; +} XrSpacesEraseInfoMETA; + +typedef struct XrEventDataSpacesEraseResultMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAsyncRequestIdFB requestId; + XrResult result; +} XrEventDataSpacesEraseResultMETA; + +typedef XrResult (XRAPI_PTR *PFN_xrSaveSpacesMETA)(XrSession session, const XrSpacesSaveInfoMETA* info, XrAsyncRequestIdFB* requestId); +typedef XrResult (XRAPI_PTR *PFN_xrEraseSpacesMETA)(XrSession session, const XrSpacesEraseInfoMETA* info, XrAsyncRequestIdFB* requestId); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrSaveSpacesMETA( + XrSession session, + const XrSpacesSaveInfoMETA* info, + XrAsyncRequestIdFB* requestId); + +XRAPI_ATTR XrResult XRAPI_CALL xrEraseSpacesMETA( + XrSession session, + const XrSpacesEraseInfoMETA* info, + XrAsyncRequestIdFB* requestId); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_META_passthrough_color_lut is a preprocessor guard. Do not pass it to API calls. +#define XR_META_passthrough_color_lut 1 +XR_DEFINE_HANDLE(XrPassthroughColorLutMETA) +#define XR_META_passthrough_color_lut_SPEC_VERSION 1 +#define XR_META_PASSTHROUGH_COLOR_LUT_EXTENSION_NAME "XR_META_passthrough_color_lut" + +typedef enum XrPassthroughColorLutChannelsMETA { + XR_PASSTHROUGH_COLOR_LUT_CHANNELS_RGB_META = 1, + XR_PASSTHROUGH_COLOR_LUT_CHANNELS_RGBA_META = 2, + XR_PASSTHROUGH_COLOR_LUT_CHANNELS_MAX_ENUM_META = 0x7FFFFFFF +} XrPassthroughColorLutChannelsMETA; +typedef struct XrPassthroughColorLutDataMETA { + uint32_t bufferSize; + const uint8_t* buffer; +} XrPassthroughColorLutDataMETA; + +typedef struct XrPassthroughColorLutCreateInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPassthroughColorLutChannelsMETA channels; + uint32_t resolution; + XrPassthroughColorLutDataMETA data; +} XrPassthroughColorLutCreateInfoMETA; + +typedef struct XrPassthroughColorLutUpdateInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPassthroughColorLutDataMETA data; +} XrPassthroughColorLutUpdateInfoMETA; + +// XrPassthroughColorMapLutMETA extends XrPassthroughStyleFB +typedef struct XrPassthroughColorMapLutMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPassthroughColorLutMETA colorLut; + float weight; +} XrPassthroughColorMapLutMETA; + +// XrPassthroughColorMapInterpolatedLutMETA extends XrPassthroughStyleFB +typedef struct XrPassthroughColorMapInterpolatedLutMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPassthroughColorLutMETA sourceColorLut; + XrPassthroughColorLutMETA targetColorLut; + float weight; +} XrPassthroughColorMapInterpolatedLutMETA; + +// XrSystemPassthroughColorLutPropertiesMETA extends XrSystemProperties +typedef struct XrSystemPassthroughColorLutPropertiesMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t maxColorLutResolution; +} XrSystemPassthroughColorLutPropertiesMETA; + +typedef XrResult (XRAPI_PTR *PFN_xrCreatePassthroughColorLutMETA)(XrPassthroughFB passthrough, const XrPassthroughColorLutCreateInfoMETA* createInfo, XrPassthroughColorLutMETA* colorLut); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyPassthroughColorLutMETA)(XrPassthroughColorLutMETA colorLut); +typedef XrResult (XRAPI_PTR *PFN_xrUpdatePassthroughColorLutMETA)(XrPassthroughColorLutMETA colorLut, const XrPassthroughColorLutUpdateInfoMETA* updateInfo); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreatePassthroughColorLutMETA( + XrPassthroughFB passthrough, + const XrPassthroughColorLutCreateInfoMETA* createInfo, + XrPassthroughColorLutMETA* colorLut); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyPassthroughColorLutMETA( + XrPassthroughColorLutMETA colorLut); + +XRAPI_ATTR XrResult XRAPI_CALL xrUpdatePassthroughColorLutMETA( + XrPassthroughColorLutMETA colorLut, + const XrPassthroughColorLutUpdateInfoMETA* updateInfo); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_META_spatial_entity_mesh is a preprocessor guard. Do not pass it to API calls. +#define XR_META_spatial_entity_mesh 1 +#define XR_META_spatial_entity_mesh_SPEC_VERSION 1 +#define XR_META_SPATIAL_ENTITY_MESH_EXTENSION_NAME "XR_META_spatial_entity_mesh" +typedef struct XrSpaceTriangleMeshGetInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrSpaceTriangleMeshGetInfoMETA; + +typedef struct XrSpaceTriangleMeshMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t vertexCapacityInput; + uint32_t vertexCountOutput; + XrVector3f* vertices; + uint32_t indexCapacityInput; + uint32_t indexCountOutput; + uint32_t* indices; +} XrSpaceTriangleMeshMETA; + +typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceTriangleMeshMETA)(XrSpace space, const XrSpaceTriangleMeshGetInfoMETA* getInfo, XrSpaceTriangleMeshMETA* triangleMeshOutput); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceTriangleMeshMETA( + XrSpace space, + const XrSpaceTriangleMeshGetInfoMETA* getInfo, + XrSpaceTriangleMeshMETA* triangleMeshOutput); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_META_automatic_layer_filter is a preprocessor guard. Do not pass it to API calls. +#define XR_META_automatic_layer_filter 1 +#define XR_META_automatic_layer_filter_SPEC_VERSION 1 +#define XR_META_AUTOMATIC_LAYER_FILTER_EXTENSION_NAME "XR_META_automatic_layer_filter" + + +// XR_META_body_tracking_full_body is a preprocessor guard. Do not pass it to API calls. +#define XR_META_body_tracking_full_body 1 +#define XR_META_body_tracking_full_body_SPEC_VERSION 1 +#define XR_META_BODY_TRACKING_FULL_BODY_EXTENSION_NAME "XR_META_body_tracking_full_body" + +typedef enum XrFullBodyJointMETA { + XR_FULL_BODY_JOINT_ROOT_META = 0, + XR_FULL_BODY_JOINT_HIPS_META = 1, + XR_FULL_BODY_JOINT_SPINE_LOWER_META = 2, + XR_FULL_BODY_JOINT_SPINE_MIDDLE_META = 3, + XR_FULL_BODY_JOINT_SPINE_UPPER_META = 4, + XR_FULL_BODY_JOINT_CHEST_META = 5, + XR_FULL_BODY_JOINT_NECK_META = 6, + XR_FULL_BODY_JOINT_HEAD_META = 7, + XR_FULL_BODY_JOINT_LEFT_SHOULDER_META = 8, + XR_FULL_BODY_JOINT_LEFT_SCAPULA_META = 9, + XR_FULL_BODY_JOINT_LEFT_ARM_UPPER_META = 10, + XR_FULL_BODY_JOINT_LEFT_ARM_LOWER_META = 11, + XR_FULL_BODY_JOINT_LEFT_HAND_WRIST_TWIST_META = 12, + XR_FULL_BODY_JOINT_RIGHT_SHOULDER_META = 13, + XR_FULL_BODY_JOINT_RIGHT_SCAPULA_META = 14, + XR_FULL_BODY_JOINT_RIGHT_ARM_UPPER_META = 15, + XR_FULL_BODY_JOINT_RIGHT_ARM_LOWER_META = 16, + XR_FULL_BODY_JOINT_RIGHT_HAND_WRIST_TWIST_META = 17, + XR_FULL_BODY_JOINT_LEFT_HAND_PALM_META = 18, + XR_FULL_BODY_JOINT_LEFT_HAND_WRIST_META = 19, + XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_METACARPAL_META = 20, + XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_PROXIMAL_META = 21, + XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_DISTAL_META = 22, + XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_TIP_META = 23, + XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_METACARPAL_META = 24, + XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_PROXIMAL_META = 25, + XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_INTERMEDIATE_META = 26, + XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_DISTAL_META = 27, + XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_TIP_META = 28, + XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_METACARPAL_META = 29, + XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_PROXIMAL_META = 30, + XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_INTERMEDIATE_META = 31, + XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_DISTAL_META = 32, + XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_TIP_META = 33, + XR_FULL_BODY_JOINT_LEFT_HAND_RING_METACARPAL_META = 34, + XR_FULL_BODY_JOINT_LEFT_HAND_RING_PROXIMAL_META = 35, + XR_FULL_BODY_JOINT_LEFT_HAND_RING_INTERMEDIATE_META = 36, + XR_FULL_BODY_JOINT_LEFT_HAND_RING_DISTAL_META = 37, + XR_FULL_BODY_JOINT_LEFT_HAND_RING_TIP_META = 38, + XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_METACARPAL_META = 39, + XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_PROXIMAL_META = 40, + XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_INTERMEDIATE_META = 41, + XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_DISTAL_META = 42, + XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_TIP_META = 43, + XR_FULL_BODY_JOINT_RIGHT_HAND_PALM_META = 44, + XR_FULL_BODY_JOINT_RIGHT_HAND_WRIST_META = 45, + XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_METACARPAL_META = 46, + XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_PROXIMAL_META = 47, + XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_DISTAL_META = 48, + XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_TIP_META = 49, + XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_METACARPAL_META = 50, + XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_PROXIMAL_META = 51, + XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_INTERMEDIATE_META = 52, + XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_DISTAL_META = 53, + XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_TIP_META = 54, + XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_METACARPAL_META = 55, + XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_PROXIMAL_META = 56, + XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_INTERMEDIATE_META = 57, + XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_DISTAL_META = 58, + XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_TIP_META = 59, + XR_FULL_BODY_JOINT_RIGHT_HAND_RING_METACARPAL_META = 60, + XR_FULL_BODY_JOINT_RIGHT_HAND_RING_PROXIMAL_META = 61, + XR_FULL_BODY_JOINT_RIGHT_HAND_RING_INTERMEDIATE_META = 62, + XR_FULL_BODY_JOINT_RIGHT_HAND_RING_DISTAL_META = 63, + XR_FULL_BODY_JOINT_RIGHT_HAND_RING_TIP_META = 64, + XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_METACARPAL_META = 65, + XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_PROXIMAL_META = 66, + XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_INTERMEDIATE_META = 67, + XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_DISTAL_META = 68, + XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_TIP_META = 69, + XR_FULL_BODY_JOINT_LEFT_UPPER_LEG_META = 70, + XR_FULL_BODY_JOINT_LEFT_LOWER_LEG_META = 71, + XR_FULL_BODY_JOINT_LEFT_FOOT_ANKLE_TWIST_META = 72, + XR_FULL_BODY_JOINT_LEFT_FOOT_ANKLE_META = 73, + XR_FULL_BODY_JOINT_LEFT_FOOT_SUBTALAR_META = 74, + XR_FULL_BODY_JOINT_LEFT_FOOT_TRANSVERSE_META = 75, + XR_FULL_BODY_JOINT_LEFT_FOOT_BALL_META = 76, + XR_FULL_BODY_JOINT_RIGHT_UPPER_LEG_META = 77, + XR_FULL_BODY_JOINT_RIGHT_LOWER_LEG_META = 78, + XR_FULL_BODY_JOINT_RIGHT_FOOT_ANKLE_TWIST_META = 79, + XR_FULL_BODY_JOINT_RIGHT_FOOT_ANKLE_META = 80, + XR_FULL_BODY_JOINT_RIGHT_FOOT_SUBTALAR_META = 81, + XR_FULL_BODY_JOINT_RIGHT_FOOT_TRANSVERSE_META = 82, + XR_FULL_BODY_JOINT_RIGHT_FOOT_BALL_META = 83, + XR_FULL_BODY_JOINT_COUNT_META = 84, + XR_FULL_BODY_JOINT_NONE_META = 85, + XR_FULL_BODY_JOINT_MAX_ENUM_META = 0x7FFFFFFF +} XrFullBodyJointMETA; +// XrSystemPropertiesBodyTrackingFullBodyMETA extends XrSystemProperties +typedef struct XrSystemPropertiesBodyTrackingFullBodyMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsFullBodyTracking; +} XrSystemPropertiesBodyTrackingFullBodyMETA; + + + +// XR_META_touch_controller_plus is a preprocessor guard. Do not pass it to API calls. +#define XR_META_touch_controller_plus 1 +#define XR_META_touch_controller_plus_SPEC_VERSION 1 +#define XR_META_TOUCH_CONTROLLER_PLUS_EXTENSION_NAME "XR_META_touch_controller_plus" + + +// XR_META_passthrough_layer_resumed_event is a preprocessor guard. Do not pass it to API calls. +#define XR_META_passthrough_layer_resumed_event 1 +#define XR_META_passthrough_layer_resumed_event_SPEC_VERSION 1 +#define XR_META_PASSTHROUGH_LAYER_RESUMED_EVENT_EXTENSION_NAME "XR_META_passthrough_layer_resumed_event" +typedef struct XrEventDataPassthroughLayerResumedMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPassthroughLayerFB layer; +} XrEventDataPassthroughLayerResumedMETA; + + + +// XR_META_body_tracking_calibration is a preprocessor guard. Do not pass it to API calls. +#define XR_META_body_tracking_calibration 1 +#define XR_META_body_tracking_calibration_SPEC_VERSION 1 +#define XR_META_BODY_TRACKING_CALIBRATION_EXTENSION_NAME "XR_META_body_tracking_calibration" + +typedef enum XrBodyTrackingCalibrationStateMETA { + XR_BODY_TRACKING_CALIBRATION_STATE_VALID_META = 1, + XR_BODY_TRACKING_CALIBRATION_STATE_CALIBRATING_META = 2, + XR_BODY_TRACKING_CALIBRATION_STATE_INVALID_META = 3, + XR_BODY_TRACKING_CALIBRATION_STATE_MAX_ENUM_META = 0x7FFFFFFF +} XrBodyTrackingCalibrationStateMETA; +// XrBodyTrackingCalibrationStatusMETA extends XrBodyJointLocationsFB +typedef struct XrBodyTrackingCalibrationStatusMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBodyTrackingCalibrationStateMETA status; +} XrBodyTrackingCalibrationStatusMETA; + +typedef struct XrBodyTrackingCalibrationInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + float bodyHeight; +} XrBodyTrackingCalibrationInfoMETA; + +// XrSystemPropertiesBodyTrackingCalibrationMETA extends XrSystemProperties +typedef struct XrSystemPropertiesBodyTrackingCalibrationMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsHeightOverride; +} XrSystemPropertiesBodyTrackingCalibrationMETA; + +typedef XrResult (XRAPI_PTR *PFN_xrSuggestBodyTrackingCalibrationOverrideMETA)(XrBodyTrackerFB bodyTracker, const XrBodyTrackingCalibrationInfoMETA* calibrationInfo); +typedef XrResult (XRAPI_PTR *PFN_xrResetBodyTrackingCalibrationMETA)(XrBodyTrackerFB bodyTracker); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrSuggestBodyTrackingCalibrationOverrideMETA( + XrBodyTrackerFB bodyTracker, + const XrBodyTrackingCalibrationInfoMETA* calibrationInfo); + +XRAPI_ATTR XrResult XRAPI_CALL xrResetBodyTrackingCalibrationMETA( + XrBodyTrackerFB bodyTracker); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_META_body_tracking_fidelity is a preprocessor guard. Do not pass it to API calls. +#define XR_META_body_tracking_fidelity 1 +#define XR_META_body_tracking_fidelity_SPEC_VERSION 1 +#define XR_META_BODY_TRACKING_FIDELITY_EXTENSION_NAME "XR_META_body_tracking_fidelity" + +typedef enum XrBodyTrackingFidelityMETA { + XR_BODY_TRACKING_FIDELITY_LOW_META = 1, + XR_BODY_TRACKING_FIDELITY_HIGH_META = 2, + XR_BODY_TRACKING_FIDELITY_MAX_ENUM_META = 0x7FFFFFFF +} XrBodyTrackingFidelityMETA; +// XrSystemPropertiesBodyTrackingFidelityMETA extends XrSystemProperties +typedef struct XrSystemPropertiesBodyTrackingFidelityMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsBodyTrackingFidelity; +} XrSystemPropertiesBodyTrackingFidelityMETA; + +// XrBodyTrackingFidelityStatusMETA extends XrBodyJointLocationsFB +typedef struct XrBodyTrackingFidelityStatusMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBodyTrackingFidelityMETA fidelity; +} XrBodyTrackingFidelityStatusMETA; + +typedef XrResult (XRAPI_PTR *PFN_xrRequestBodyTrackingFidelityMETA)(XrBodyTrackerFB bodyTracker, const XrBodyTrackingFidelityMETA fidelity); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrRequestBodyTrackingFidelityMETA( + XrBodyTrackerFB bodyTracker, + const XrBodyTrackingFidelityMETA fidelity); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_FB_face_tracking2 is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_face_tracking2 1 +XR_DEFINE_HANDLE(XrFaceTracker2FB) +#define XR_FB_face_tracking2_SPEC_VERSION 1 +#define XR_FB_FACE_TRACKING2_EXTENSION_NAME "XR_FB_face_tracking2" + +typedef enum XrFaceExpression2FB { + XR_FACE_EXPRESSION2_BROW_LOWERER_L_FB = 0, + XR_FACE_EXPRESSION2_BROW_LOWERER_R_FB = 1, + XR_FACE_EXPRESSION2_CHEEK_PUFF_L_FB = 2, + XR_FACE_EXPRESSION2_CHEEK_PUFF_R_FB = 3, + XR_FACE_EXPRESSION2_CHEEK_RAISER_L_FB = 4, + XR_FACE_EXPRESSION2_CHEEK_RAISER_R_FB = 5, + XR_FACE_EXPRESSION2_CHEEK_SUCK_L_FB = 6, + XR_FACE_EXPRESSION2_CHEEK_SUCK_R_FB = 7, + XR_FACE_EXPRESSION2_CHIN_RAISER_B_FB = 8, + XR_FACE_EXPRESSION2_CHIN_RAISER_T_FB = 9, + XR_FACE_EXPRESSION2_DIMPLER_L_FB = 10, + XR_FACE_EXPRESSION2_DIMPLER_R_FB = 11, + XR_FACE_EXPRESSION2_EYES_CLOSED_L_FB = 12, + XR_FACE_EXPRESSION2_EYES_CLOSED_R_FB = 13, + XR_FACE_EXPRESSION2_EYES_LOOK_DOWN_L_FB = 14, + XR_FACE_EXPRESSION2_EYES_LOOK_DOWN_R_FB = 15, + XR_FACE_EXPRESSION2_EYES_LOOK_LEFT_L_FB = 16, + XR_FACE_EXPRESSION2_EYES_LOOK_LEFT_R_FB = 17, + XR_FACE_EXPRESSION2_EYES_LOOK_RIGHT_L_FB = 18, + XR_FACE_EXPRESSION2_EYES_LOOK_RIGHT_R_FB = 19, + XR_FACE_EXPRESSION2_EYES_LOOK_UP_L_FB = 20, + XR_FACE_EXPRESSION2_EYES_LOOK_UP_R_FB = 21, + XR_FACE_EXPRESSION2_INNER_BROW_RAISER_L_FB = 22, + XR_FACE_EXPRESSION2_INNER_BROW_RAISER_R_FB = 23, + XR_FACE_EXPRESSION2_JAW_DROP_FB = 24, + XR_FACE_EXPRESSION2_JAW_SIDEWAYS_LEFT_FB = 25, + XR_FACE_EXPRESSION2_JAW_SIDEWAYS_RIGHT_FB = 26, + XR_FACE_EXPRESSION2_JAW_THRUST_FB = 27, + XR_FACE_EXPRESSION2_LID_TIGHTENER_L_FB = 28, + XR_FACE_EXPRESSION2_LID_TIGHTENER_R_FB = 29, + XR_FACE_EXPRESSION2_LIP_CORNER_DEPRESSOR_L_FB = 30, + XR_FACE_EXPRESSION2_LIP_CORNER_DEPRESSOR_R_FB = 31, + XR_FACE_EXPRESSION2_LIP_CORNER_PULLER_L_FB = 32, + XR_FACE_EXPRESSION2_LIP_CORNER_PULLER_R_FB = 33, + XR_FACE_EXPRESSION2_LIP_FUNNELER_LB_FB = 34, + XR_FACE_EXPRESSION2_LIP_FUNNELER_LT_FB = 35, + XR_FACE_EXPRESSION2_LIP_FUNNELER_RB_FB = 36, + XR_FACE_EXPRESSION2_LIP_FUNNELER_RT_FB = 37, + XR_FACE_EXPRESSION2_LIP_PRESSOR_L_FB = 38, + XR_FACE_EXPRESSION2_LIP_PRESSOR_R_FB = 39, + XR_FACE_EXPRESSION2_LIP_PUCKER_L_FB = 40, + XR_FACE_EXPRESSION2_LIP_PUCKER_R_FB = 41, + XR_FACE_EXPRESSION2_LIP_STRETCHER_L_FB = 42, + XR_FACE_EXPRESSION2_LIP_STRETCHER_R_FB = 43, + XR_FACE_EXPRESSION2_LIP_SUCK_LB_FB = 44, + XR_FACE_EXPRESSION2_LIP_SUCK_LT_FB = 45, + XR_FACE_EXPRESSION2_LIP_SUCK_RB_FB = 46, + XR_FACE_EXPRESSION2_LIP_SUCK_RT_FB = 47, + XR_FACE_EXPRESSION2_LIP_TIGHTENER_L_FB = 48, + XR_FACE_EXPRESSION2_LIP_TIGHTENER_R_FB = 49, + XR_FACE_EXPRESSION2_LIPS_TOWARD_FB = 50, + XR_FACE_EXPRESSION2_LOWER_LIP_DEPRESSOR_L_FB = 51, + XR_FACE_EXPRESSION2_LOWER_LIP_DEPRESSOR_R_FB = 52, + XR_FACE_EXPRESSION2_MOUTH_LEFT_FB = 53, + XR_FACE_EXPRESSION2_MOUTH_RIGHT_FB = 54, + XR_FACE_EXPRESSION2_NOSE_WRINKLER_L_FB = 55, + XR_FACE_EXPRESSION2_NOSE_WRINKLER_R_FB = 56, + XR_FACE_EXPRESSION2_OUTER_BROW_RAISER_L_FB = 57, + XR_FACE_EXPRESSION2_OUTER_BROW_RAISER_R_FB = 58, + XR_FACE_EXPRESSION2_UPPER_LID_RAISER_L_FB = 59, + XR_FACE_EXPRESSION2_UPPER_LID_RAISER_R_FB = 60, + XR_FACE_EXPRESSION2_UPPER_LIP_RAISER_L_FB = 61, + XR_FACE_EXPRESSION2_UPPER_LIP_RAISER_R_FB = 62, + XR_FACE_EXPRESSION2_TONGUE_TIP_INTERDENTAL_FB = 63, + XR_FACE_EXPRESSION2_TONGUE_TIP_ALVEOLAR_FB = 64, + XR_FACE_EXPRESSION2_TONGUE_FRONT_DORSAL_PALATE_FB = 65, + XR_FACE_EXPRESSION2_TONGUE_MID_DORSAL_PALATE_FB = 66, + XR_FACE_EXPRESSION2_TONGUE_BACK_DORSAL_VELAR_FB = 67, + XR_FACE_EXPRESSION2_TONGUE_OUT_FB = 68, + XR_FACE_EXPRESSION2_TONGUE_RETREAT_FB = 69, + XR_FACE_EXPRESSION2_COUNT_FB = 70, + XR_FACE_EXPRESSION_2FB_MAX_ENUM_FB = 0x7FFFFFFF +} XrFaceExpression2FB; + +typedef enum XrFaceExpressionSet2FB { + XR_FACE_EXPRESSION_SET2_DEFAULT_FB = 0, + XR_FACE_EXPRESSION_SET_2FB_MAX_ENUM_FB = 0x7FFFFFFF +} XrFaceExpressionSet2FB; + +typedef enum XrFaceTrackingDataSource2FB { + XR_FACE_TRACKING_DATA_SOURCE2_VISUAL_FB = 0, + XR_FACE_TRACKING_DATA_SOURCE2_AUDIO_FB = 1, + XR_FACE_TRACKING_DATA_SOURCE_2FB_MAX_ENUM_FB = 0x7FFFFFFF +} XrFaceTrackingDataSource2FB; + +typedef enum XrFaceConfidence2FB { + XR_FACE_CONFIDENCE2_LOWER_FACE_FB = 0, + XR_FACE_CONFIDENCE2_UPPER_FACE_FB = 1, + XR_FACE_CONFIDENCE2_COUNT_FB = 2, + XR_FACE_CONFIDENCE_2FB_MAX_ENUM_FB = 0x7FFFFFFF +} XrFaceConfidence2FB; +// XrSystemFaceTrackingProperties2FB extends XrSystemProperties +typedef struct XrSystemFaceTrackingProperties2FB { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsVisualFaceTracking; + XrBool32 supportsAudioFaceTracking; +} XrSystemFaceTrackingProperties2FB; + +typedef struct XrFaceTrackerCreateInfo2FB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrFaceExpressionSet2FB faceExpressionSet; + uint32_t requestedDataSourceCount; + XrFaceTrackingDataSource2FB* requestedDataSources; +} XrFaceTrackerCreateInfo2FB; + +typedef struct XrFaceExpressionInfo2FB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrTime time; +} XrFaceExpressionInfo2FB; + +typedef struct XrFaceExpressionWeights2FB { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t weightCount; + float* weights; + uint32_t confidenceCount; + float* confidences; + XrBool32 isValid; + XrBool32 isEyeFollowingBlendshapesValid; + XrFaceTrackingDataSource2FB dataSource; + XrTime time; +} XrFaceExpressionWeights2FB; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateFaceTracker2FB)(XrSession session, const XrFaceTrackerCreateInfo2FB* createInfo, XrFaceTracker2FB* faceTracker); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyFaceTracker2FB)(XrFaceTracker2FB faceTracker); +typedef XrResult (XRAPI_PTR *PFN_xrGetFaceExpressionWeights2FB)(XrFaceTracker2FB faceTracker, const XrFaceExpressionInfo2FB* expressionInfo, XrFaceExpressionWeights2FB* expressionWeights); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateFaceTracker2FB( + XrSession session, + const XrFaceTrackerCreateInfo2FB* createInfo, + XrFaceTracker2FB* faceTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyFaceTracker2FB( + XrFaceTracker2FB faceTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetFaceExpressionWeights2FB( + XrFaceTracker2FB faceTracker, + const XrFaceExpressionInfo2FB* expressionInfo, + XrFaceExpressionWeights2FB* expressionWeights); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_META_spatial_entity_sharing is a preprocessor guard. Do not pass it to API calls. +#define XR_META_spatial_entity_sharing 1 +#define XR_META_spatial_entity_sharing_SPEC_VERSION 1 +#define XR_META_SPATIAL_ENTITY_SHARING_EXTENSION_NAME "XR_META_spatial_entity_sharing" +#define XR_MAX_SPACES_PER_SHARE_REQUEST_META 32 +// XrSystemSpatialEntitySharingPropertiesMETA extends XrSystemProperties +typedef struct XrSystemSpatialEntitySharingPropertiesMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsSpatialEntitySharing; +} XrSystemSpatialEntitySharingPropertiesMETA; + +typedef struct XR_MAY_ALIAS XrShareSpacesRecipientBaseHeaderMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrShareSpacesRecipientBaseHeaderMETA; + +typedef struct XrShareSpacesInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t spaceCount; + XrSpace* spaces; + const XrShareSpacesRecipientBaseHeaderMETA* recipientInfo; +} XrShareSpacesInfoMETA; + +typedef struct XrEventDataShareSpacesCompleteMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAsyncRequestIdFB requestId; + XrResult result; +} XrEventDataShareSpacesCompleteMETA; + +typedef XrResult (XRAPI_PTR *PFN_xrShareSpacesMETA)(XrSession session, const XrShareSpacesInfoMETA* info, XrAsyncRequestIdFB* requestId); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrShareSpacesMETA( + XrSession session, + const XrShareSpacesInfoMETA* info, + XrAsyncRequestIdFB* requestId); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_META_environment_depth is a preprocessor guard. Do not pass it to API calls. +#define XR_META_environment_depth 1 +XR_DEFINE_HANDLE(XrEnvironmentDepthProviderMETA) +XR_DEFINE_HANDLE(XrEnvironmentDepthSwapchainMETA) +#define XR_META_environment_depth_SPEC_VERSION 2 +#define XR_META_ENVIRONMENT_DEPTH_EXTENSION_NAME "XR_META_environment_depth" +typedef XrFlags64 XrEnvironmentDepthProviderCreateFlagsMETA; + +// Flag bits for XrEnvironmentDepthProviderCreateFlagsMETA + +typedef XrFlags64 XrEnvironmentDepthSwapchainCreateFlagsMETA; + +// Flag bits for XrEnvironmentDepthSwapchainCreateFlagsMETA + +typedef struct XrEnvironmentDepthProviderCreateInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrEnvironmentDepthProviderCreateFlagsMETA createFlags; +} XrEnvironmentDepthProviderCreateInfoMETA; + +typedef struct XrEnvironmentDepthSwapchainCreateInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrEnvironmentDepthSwapchainCreateFlagsMETA createFlags; +} XrEnvironmentDepthSwapchainCreateInfoMETA; + +typedef struct XrEnvironmentDepthSwapchainStateMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t width; + uint32_t height; +} XrEnvironmentDepthSwapchainStateMETA; + +typedef struct XrEnvironmentDepthImageAcquireInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace space; + XrTime displayTime; +} XrEnvironmentDepthImageAcquireInfoMETA; + +typedef struct XrEnvironmentDepthImageViewMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrFovf fov; + XrPosef pose; +} XrEnvironmentDepthImageViewMETA; + +typedef struct XrEnvironmentDepthImageMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t swapchainIndex; + float nearZ; + float farZ; + XrEnvironmentDepthImageViewMETA views[2]; +} XrEnvironmentDepthImageMETA; + +// XrEnvironmentDepthImageTimestampMETA extends XrEnvironmentDepthImageMETA +typedef struct XrEnvironmentDepthImageTimestampMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrTime captureTime; +} XrEnvironmentDepthImageTimestampMETA; + +typedef struct XrEnvironmentDepthHandRemovalSetInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 enabled; +} XrEnvironmentDepthHandRemovalSetInfoMETA; + +// XrSystemEnvironmentDepthPropertiesMETA extends XrSystemProperties +typedef struct XrSystemEnvironmentDepthPropertiesMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsEnvironmentDepth; + XrBool32 supportsHandRemoval; +} XrSystemEnvironmentDepthPropertiesMETA; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateEnvironmentDepthProviderMETA)(XrSession session, const XrEnvironmentDepthProviderCreateInfoMETA* createInfo, XrEnvironmentDepthProviderMETA* environmentDepthProvider); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyEnvironmentDepthProviderMETA)(XrEnvironmentDepthProviderMETA environmentDepthProvider); +typedef XrResult (XRAPI_PTR *PFN_xrStartEnvironmentDepthProviderMETA)(XrEnvironmentDepthProviderMETA environmentDepthProvider); +typedef XrResult (XRAPI_PTR *PFN_xrStopEnvironmentDepthProviderMETA)(XrEnvironmentDepthProviderMETA environmentDepthProvider); +typedef XrResult (XRAPI_PTR *PFN_xrCreateEnvironmentDepthSwapchainMETA)(XrEnvironmentDepthProviderMETA environmentDepthProvider, const XrEnvironmentDepthSwapchainCreateInfoMETA* createInfo, XrEnvironmentDepthSwapchainMETA* swapchain); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyEnvironmentDepthSwapchainMETA)(XrEnvironmentDepthSwapchainMETA swapchain); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateEnvironmentDepthSwapchainImagesMETA)(XrEnvironmentDepthSwapchainMETA swapchain, uint32_t imageCapacityInput, uint32_t* imageCountOutput, XrSwapchainImageBaseHeader* images); +typedef XrResult (XRAPI_PTR *PFN_xrGetEnvironmentDepthSwapchainStateMETA)(XrEnvironmentDepthSwapchainMETA swapchain, XrEnvironmentDepthSwapchainStateMETA* state); +typedef XrResult (XRAPI_PTR *PFN_xrAcquireEnvironmentDepthImageMETA)(XrEnvironmentDepthProviderMETA environmentDepthProvider, const XrEnvironmentDepthImageAcquireInfoMETA* acquireInfo, XrEnvironmentDepthImageMETA* environmentDepthImage); +typedef XrResult (XRAPI_PTR *PFN_xrSetEnvironmentDepthHandRemovalMETA)(XrEnvironmentDepthProviderMETA environmentDepthProvider, const XrEnvironmentDepthHandRemovalSetInfoMETA* setInfo); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateEnvironmentDepthProviderMETA( + XrSession session, + const XrEnvironmentDepthProviderCreateInfoMETA* createInfo, + XrEnvironmentDepthProviderMETA* environmentDepthProvider); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyEnvironmentDepthProviderMETA( + XrEnvironmentDepthProviderMETA environmentDepthProvider); + +XRAPI_ATTR XrResult XRAPI_CALL xrStartEnvironmentDepthProviderMETA( + XrEnvironmentDepthProviderMETA environmentDepthProvider); + +XRAPI_ATTR XrResult XRAPI_CALL xrStopEnvironmentDepthProviderMETA( + XrEnvironmentDepthProviderMETA environmentDepthProvider); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateEnvironmentDepthSwapchainMETA( + XrEnvironmentDepthProviderMETA environmentDepthProvider, + const XrEnvironmentDepthSwapchainCreateInfoMETA* createInfo, + XrEnvironmentDepthSwapchainMETA* swapchain); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyEnvironmentDepthSwapchainMETA( + XrEnvironmentDepthSwapchainMETA swapchain); + +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateEnvironmentDepthSwapchainImagesMETA( + XrEnvironmentDepthSwapchainMETA swapchain, + uint32_t imageCapacityInput, + uint32_t* imageCountOutput, + XrSwapchainImageBaseHeader* images); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetEnvironmentDepthSwapchainStateMETA( + XrEnvironmentDepthSwapchainMETA swapchain, + XrEnvironmentDepthSwapchainStateMETA* state); + +XRAPI_ATTR XrResult XRAPI_CALL xrAcquireEnvironmentDepthImageMETA( + XrEnvironmentDepthProviderMETA environmentDepthProvider, + const XrEnvironmentDepthImageAcquireInfoMETA* acquireInfo, + XrEnvironmentDepthImageMETA* environmentDepthImage); + +XRAPI_ATTR XrResult XRAPI_CALL xrSetEnvironmentDepthHandRemovalMETA( + XrEnvironmentDepthProviderMETA environmentDepthProvider, + const XrEnvironmentDepthHandRemovalSetInfoMETA* setInfo); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_EXT_uuid is a preprocessor guard. Do not pass it to API calls. +#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 + + +// XR_EXT_render_model is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_render_model 1 +XR_DEFINE_ATOM(XrRenderModelIdEXT) +XR_DEFINE_HANDLE(XrRenderModelEXT) +XR_DEFINE_HANDLE(XrRenderModelAssetEXT) +#define XR_MAX_RENDER_MODEL_ASSET_NODE_NAME_SIZE_EXT 64 +#define XR_EXT_render_model_SPEC_VERSION 1 +#define XR_EXT_RENDER_MODEL_EXTENSION_NAME "XR_EXT_render_model" +#define XR_NULL_RENDER_MODEL_ID_EXT 0 +typedef struct XrRenderModelCreateInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrRenderModelIdEXT renderModelId; + uint32_t gltfExtensionCount; + const char* const* gltfExtensions; +} XrRenderModelCreateInfoEXT; + +typedef struct XrRenderModelPropertiesGetInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrRenderModelPropertiesGetInfoEXT; + +typedef struct XrRenderModelPropertiesEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrUuidEXT cacheId; + uint32_t animatableNodeCount; +} XrRenderModelPropertiesEXT; + +typedef struct XrRenderModelSpaceCreateInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrRenderModelEXT renderModel; +} XrRenderModelSpaceCreateInfoEXT; + +typedef struct XrRenderModelStateGetInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrTime displayTime; +} XrRenderModelStateGetInfoEXT; + +typedef struct XrRenderModelNodeStateEXT { + XrPosef nodePose; + XrBool32 isVisible; +} XrRenderModelNodeStateEXT; + +typedef struct XrRenderModelStateEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t nodeStateCount; + XrRenderModelNodeStateEXT* nodeStates; +} XrRenderModelStateEXT; + +typedef struct XrRenderModelAssetCreateInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrUuidEXT cacheId; +} XrRenderModelAssetCreateInfoEXT; + +typedef struct XrRenderModelAssetDataGetInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrRenderModelAssetDataGetInfoEXT; + +typedef struct XrRenderModelAssetDataEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t bufferCapacityInput; + uint32_t bufferCountOutput; + uint8_t* buffer; +} XrRenderModelAssetDataEXT; + +typedef struct XrRenderModelAssetPropertiesGetInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrRenderModelAssetPropertiesGetInfoEXT; + +typedef struct XrRenderModelAssetNodePropertiesEXT { + char uniqueName[XR_MAX_RENDER_MODEL_ASSET_NODE_NAME_SIZE_EXT]; +} XrRenderModelAssetNodePropertiesEXT; + +typedef struct XrRenderModelAssetPropertiesEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t nodePropertyCount; + XrRenderModelAssetNodePropertiesEXT* nodeProperties; +} XrRenderModelAssetPropertiesEXT; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateRenderModelEXT)(XrSession session, const XrRenderModelCreateInfoEXT* createInfo, XrRenderModelEXT* renderModel); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyRenderModelEXT)(XrRenderModelEXT renderModel); +typedef XrResult (XRAPI_PTR *PFN_xrGetRenderModelPropertiesEXT)(XrRenderModelEXT renderModel, const XrRenderModelPropertiesGetInfoEXT* getInfo, XrRenderModelPropertiesEXT* properties); +typedef XrResult (XRAPI_PTR *PFN_xrCreateRenderModelSpaceEXT)(XrSession session, const XrRenderModelSpaceCreateInfoEXT* createInfo, XrSpace* space); +typedef XrResult (XRAPI_PTR *PFN_xrCreateRenderModelAssetEXT)(XrSession session, const XrRenderModelAssetCreateInfoEXT* createInfo, XrRenderModelAssetEXT* asset); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyRenderModelAssetEXT)(XrRenderModelAssetEXT asset); +typedef XrResult (XRAPI_PTR *PFN_xrGetRenderModelAssetDataEXT)(XrRenderModelAssetEXT asset, const XrRenderModelAssetDataGetInfoEXT* getInfo, XrRenderModelAssetDataEXT* buffer); +typedef XrResult (XRAPI_PTR *PFN_xrGetRenderModelAssetPropertiesEXT)(XrRenderModelAssetEXT asset, const XrRenderModelAssetPropertiesGetInfoEXT* getInfo, XrRenderModelAssetPropertiesEXT* properties); +typedef XrResult (XRAPI_PTR *PFN_xrGetRenderModelStateEXT)(XrRenderModelEXT renderModel, const XrRenderModelStateGetInfoEXT* getInfo, XrRenderModelStateEXT* state); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateRenderModelEXT( + XrSession session, + const XrRenderModelCreateInfoEXT* createInfo, + XrRenderModelEXT* renderModel); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyRenderModelEXT( + XrRenderModelEXT renderModel); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetRenderModelPropertiesEXT( + XrRenderModelEXT renderModel, + const XrRenderModelPropertiesGetInfoEXT* getInfo, + XrRenderModelPropertiesEXT* properties); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateRenderModelSpaceEXT( + XrSession session, + const XrRenderModelSpaceCreateInfoEXT* createInfo, + XrSpace* space); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateRenderModelAssetEXT( + XrSession session, + const XrRenderModelAssetCreateInfoEXT* createInfo, + XrRenderModelAssetEXT* asset); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyRenderModelAssetEXT( + XrRenderModelAssetEXT asset); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetRenderModelAssetDataEXT( + XrRenderModelAssetEXT asset, + const XrRenderModelAssetDataGetInfoEXT* getInfo, + XrRenderModelAssetDataEXT* buffer); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetRenderModelAssetPropertiesEXT( + XrRenderModelAssetEXT asset, + const XrRenderModelAssetPropertiesGetInfoEXT* getInfo, + XrRenderModelAssetPropertiesEXT* properties); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetRenderModelStateEXT( + XrRenderModelEXT renderModel, + const XrRenderModelStateGetInfoEXT* getInfo, + XrRenderModelStateEXT* state); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_EXT_interaction_render_model is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_interaction_render_model 1 +#define XR_EXT_interaction_render_model_SPEC_VERSION 1 +#define XR_EXT_INTERACTION_RENDER_MODEL_EXTENSION_NAME "XR_EXT_interaction_render_model" +typedef struct XrInteractionRenderModelIdsEnumerateInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrInteractionRenderModelIdsEnumerateInfoEXT; + +typedef struct XrInteractionRenderModelSubactionPathInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrInteractionRenderModelSubactionPathInfoEXT; + +typedef struct XrInteractionRenderModelTopLevelUserPathGetInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t topLevelUserPathCount; + const XrPath* topLevelUserPaths; +} XrInteractionRenderModelTopLevelUserPathGetInfoEXT; + +typedef struct XrEventDataInteractionRenderModelsChangedEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrEventDataInteractionRenderModelsChangedEXT; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateInteractionRenderModelIdsEXT)(XrSession session, const XrInteractionRenderModelIdsEnumerateInfoEXT* getInfo, uint32_t renderModelIdCapacityInput, uint32_t* renderModelIdCountOutput, XrRenderModelIdEXT* renderModelIds); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateRenderModelSubactionPathsEXT)(XrRenderModelEXT renderModel, const XrInteractionRenderModelSubactionPathInfoEXT* info, uint32_t pathCapacityInput, uint32_t* pathCountOutput, XrPath* paths); +typedef XrResult (XRAPI_PTR *PFN_xrGetRenderModelPoseTopLevelUserPathEXT)(XrRenderModelEXT renderModel, const XrInteractionRenderModelTopLevelUserPathGetInfoEXT* info, XrPath* topLevelUserPath); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateInteractionRenderModelIdsEXT( + XrSession session, + const XrInteractionRenderModelIdsEnumerateInfoEXT* getInfo, + uint32_t renderModelIdCapacityInput, + uint32_t* renderModelIdCountOutput, + XrRenderModelIdEXT* renderModelIds); + +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateRenderModelSubactionPathsEXT( + XrRenderModelEXT renderModel, + const XrInteractionRenderModelSubactionPathInfoEXT* info, + uint32_t pathCapacityInput, + uint32_t* pathCountOutput, + XrPath* paths); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetRenderModelPoseTopLevelUserPathEXT( + XrRenderModelEXT renderModel, + const XrInteractionRenderModelTopLevelUserPathGetInfoEXT* info, + XrPath* topLevelUserPath); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_EXT_hand_interaction is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_hand_interaction 1 +#define XR_EXT_hand_interaction_SPEC_VERSION 2 +#define XR_EXT_HAND_INTERACTION_EXTENSION_NAME "XR_EXT_hand_interaction" + + +// XR_QCOM_tracking_optimization_settings is a preprocessor guard. Do not pass it to API calls. +#define XR_QCOM_tracking_optimization_settings 1 +#define XR_QCOM_tracking_optimization_settings_SPEC_VERSION 2 +#define XR_QCOM_TRACKING_OPTIMIZATION_SETTINGS_EXTENSION_NAME "XR_QCOM_tracking_optimization_settings" + +typedef enum XrTrackingOptimizationSettingsDomainQCOM { + XR_TRACKING_OPTIMIZATION_SETTINGS_DOMAIN_ALL_QCOM = 1, + XR_TRACKING_OPTIMIZATION_SETTINGS_DOMAIN_MAX_ENUM_QCOM = 0x7FFFFFFF +} XrTrackingOptimizationSettingsDomainQCOM; + +typedef enum XrTrackingOptimizationSettingsHintQCOM { + XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_NONE_QCOM = 0, + XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LONG_RANGE_PRIORITIZATION_QCOM = 1, + XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_CLOSE_RANGE_PRIORITIZATION_QCOM = 2, + XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LOW_POWER_PRIORITIZATION_QCOM = 3, + XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_HIGH_POWER_PRIORITIZATION_QCOM = 4, + XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LONG_RANGE_PRIORIZATION_QCOM = XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LONG_RANGE_PRIORITIZATION_QCOM, + XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_CLOSE_RANGE_PRIORIZATION_QCOM = XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_CLOSE_RANGE_PRIORITIZATION_QCOM, + XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LOW_POWER_PRIORIZATION_QCOM = XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LOW_POWER_PRIORITIZATION_QCOM, + XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_HIGH_POWER_PRIORIZATION_QCOM = XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_HIGH_POWER_PRIORITIZATION_QCOM, + XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_MAX_ENUM_QCOM = 0x7FFFFFFF +} XrTrackingOptimizationSettingsHintQCOM; +typedef XrResult (XRAPI_PTR *PFN_xrSetTrackingOptimizationSettingsHintQCOM)(XrSession session, XrTrackingOptimizationSettingsDomainQCOM domain, XrTrackingOptimizationSettingsHintQCOM hint); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrSetTrackingOptimizationSettingsHintQCOM( + XrSession session, + XrTrackingOptimizationSettingsDomainQCOM domain, + XrTrackingOptimizationSettingsHintQCOM hint); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_QCOM_hand_tracking_gesture is a preprocessor guard. Do not pass it to API calls. +#define XR_QCOM_hand_tracking_gesture 1 +#define XR_QCOM_hand_tracking_gesture_SPEC_VERSION 1 +#define XR_QCOM_HAND_TRACKING_GESTURE_EXTENSION_NAME "XR_QCOM_hand_tracking_gesture" + +typedef enum XrHandGestureTypeQCOM { + XR_HAND_GESTURE_TYPE_UNKNOWN_QCOM = -1, + XR_HAND_GESTURE_TYPE_OPEN_HAND_QCOM = 0, + XR_HAND_GESTURE_TYPE_GRAB_QCOM = 2, + XR_HAND_GESTURE_TYPE_PINCH_QCOM = 7, + XR_HAND_GESTURE_TYPE_MAX_ENUM_QCOM = 0x7FFFFFFF +} XrHandGestureTypeQCOM; +typedef struct XrHandGestureQCOM { + XrHandGestureTypeQCOM gesture; + float gestureRatio; + float flipRatio; +} XrHandGestureQCOM; + +typedef XrResult (XRAPI_PTR *PFN_xrGetHandGestureQCOM)(XrHandTrackerEXT handTracker, XrTime time, XrHandGestureQCOM* handGesture); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetHandGestureQCOM( + XrHandTrackerEXT handTracker, + XrTime time, + XrHandGestureQCOM* handGesture); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_HTC_passthrough is a preprocessor guard. Do not pass it to API calls. +#define XR_HTC_passthrough 1 +XR_DEFINE_HANDLE(XrPassthroughHTC) +#define XR_HTC_passthrough_SPEC_VERSION 1 +#define XR_HTC_PASSTHROUGH_EXTENSION_NAME "XR_HTC_passthrough" + +typedef enum XrPassthroughFormHTC { + XR_PASSTHROUGH_FORM_PLANAR_HTC = 0, + XR_PASSTHROUGH_FORM_PROJECTED_HTC = 1, + XR_PASSTHROUGH_FORM_MAX_ENUM_HTC = 0x7FFFFFFF +} XrPassthroughFormHTC; +typedef struct XrPassthroughCreateInfoHTC { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPassthroughFormHTC form; +} XrPassthroughCreateInfoHTC; + +typedef struct XrPassthroughColorHTC { + XrStructureType type; + const void* XR_MAY_ALIAS next; + float alpha; +} XrPassthroughColorHTC; + +// XrPassthroughMeshTransformInfoHTC extends XrCompositionLayerPassthroughHTC +typedef struct XrPassthroughMeshTransformInfoHTC { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t vertexCount; + const XrVector3f* vertices; + uint32_t indexCount; + const uint32_t* indices; + XrSpace baseSpace; + XrTime time; + XrPosef pose; + XrVector3f scale; +} XrPassthroughMeshTransformInfoHTC; + +typedef struct XrCompositionLayerPassthroughHTC { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCompositionLayerFlags layerFlags; + XrSpace space; + XrPassthroughHTC passthrough; + XrPassthroughColorHTC color; +} XrCompositionLayerPassthroughHTC; + +typedef XrResult (XRAPI_PTR *PFN_xrCreatePassthroughHTC)(XrSession session, const XrPassthroughCreateInfoHTC* createInfo, XrPassthroughHTC* passthrough); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyPassthroughHTC)(XrPassthroughHTC passthrough); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreatePassthroughHTC( + XrSession session, + const XrPassthroughCreateInfoHTC* createInfo, + XrPassthroughHTC* passthrough); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyPassthroughHTC( + XrPassthroughHTC passthrough); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_HTC_foveation is a preprocessor guard. Do not pass it to API calls. +#define XR_HTC_foveation 1 +#define XR_HTC_foveation_SPEC_VERSION 1 +#define XR_HTC_FOVEATION_EXTENSION_NAME "XR_HTC_foveation" + +typedef enum XrFoveationModeHTC { + XR_FOVEATION_MODE_DISABLE_HTC = 0, + XR_FOVEATION_MODE_FIXED_HTC = 1, + XR_FOVEATION_MODE_DYNAMIC_HTC = 2, + XR_FOVEATION_MODE_CUSTOM_HTC = 3, + XR_FOVEATION_MODE_MAX_ENUM_HTC = 0x7FFFFFFF +} XrFoveationModeHTC; + +typedef enum XrFoveationLevelHTC { + XR_FOVEATION_LEVEL_NONE_HTC = 0, + XR_FOVEATION_LEVEL_LOW_HTC = 1, + XR_FOVEATION_LEVEL_MEDIUM_HTC = 2, + XR_FOVEATION_LEVEL_HIGH_HTC = 3, + XR_FOVEATION_LEVEL_MAX_ENUM_HTC = 0x7FFFFFFF +} XrFoveationLevelHTC; +typedef XrFlags64 XrFoveationDynamicFlagsHTC; + +// Flag bits for XrFoveationDynamicFlagsHTC +static const XrFoveationDynamicFlagsHTC XR_FOVEATION_DYNAMIC_LEVEL_ENABLED_BIT_HTC = 0x00000001; +static const XrFoveationDynamicFlagsHTC XR_FOVEATION_DYNAMIC_CLEAR_FOV_ENABLED_BIT_HTC = 0x00000002; +static const XrFoveationDynamicFlagsHTC XR_FOVEATION_DYNAMIC_FOCAL_CENTER_OFFSET_ENABLED_BIT_HTC = 0x00000004; + +typedef struct XrFoveationApplyInfoHTC { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrFoveationModeHTC mode; + uint32_t subImageCount; + XrSwapchainSubImage* subImages; +} XrFoveationApplyInfoHTC; + +typedef struct XrFoveationConfigurationHTC { + XrFoveationLevelHTC level; + float clearFovDegree; + XrVector2f focalCenterOffset; +} XrFoveationConfigurationHTC; + +// XrFoveationDynamicModeInfoHTC extends XrFoveationApplyInfoHTC +typedef struct XrFoveationDynamicModeInfoHTC { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrFoveationDynamicFlagsHTC dynamicFlags; +} XrFoveationDynamicModeInfoHTC; + +// XrFoveationCustomModeInfoHTC extends XrFoveationApplyInfoHTC +typedef struct XrFoveationCustomModeInfoHTC { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t configCount; + const XrFoveationConfigurationHTC* configs; +} XrFoveationCustomModeInfoHTC; + +typedef XrResult (XRAPI_PTR *PFN_xrApplyFoveationHTC)(XrSession session, const XrFoveationApplyInfoHTC* applyInfo); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrApplyFoveationHTC( + XrSession session, + const XrFoveationApplyInfoHTC* applyInfo); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_HTC_anchor is a preprocessor guard. Do not pass it to API calls. +#define XR_HTC_anchor 1 +#define XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_HTC 256 +#define XR_HTC_anchor_SPEC_VERSION 1 +#define XR_HTC_ANCHOR_EXTENSION_NAME "XR_HTC_anchor" +// XrSystemAnchorPropertiesHTC extends XrSystemProperties +typedef struct XrSystemAnchorPropertiesHTC { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsAnchor; +} XrSystemAnchorPropertiesHTC; + +typedef struct XrSpatialAnchorNameHTC { + char name[XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_HTC]; +} XrSpatialAnchorNameHTC; + +typedef struct XrSpatialAnchorCreateInfoHTC { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace space; + XrPosef poseInSpace; + XrSpatialAnchorNameHTC name; +} XrSpatialAnchorCreateInfoHTC; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorHTC)(XrSession session, const XrSpatialAnchorCreateInfoHTC* createInfo, XrSpace* anchor); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialAnchorNameHTC)(XrSpace anchor, XrSpatialAnchorNameHTC* name); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorHTC( + XrSession session, + const XrSpatialAnchorCreateInfoHTC* createInfo, + XrSpace* anchor); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialAnchorNameHTC( + XrSpace anchor, + XrSpatialAnchorNameHTC* name); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_HTC_body_tracking is a preprocessor guard. Do not pass it to API calls. +#define XR_HTC_body_tracking 1 + +#define XR_BODY_JOINT_COUNT_HTC 26 + +XR_DEFINE_HANDLE(XrBodyTrackerHTC) +#define XR_HTC_body_tracking_SPEC_VERSION 1 +#define XR_HTC_BODY_TRACKING_EXTENSION_NAME "XR_HTC_body_tracking" + +typedef enum XrBodyJointHTC { + XR_BODY_JOINT_PELVIS_HTC = 0, + XR_BODY_JOINT_LEFT_HIP_HTC = 1, + XR_BODY_JOINT_LEFT_KNEE_HTC = 2, + XR_BODY_JOINT_LEFT_ANKLE_HTC = 3, + XR_BODY_JOINT_LEFT_FEET_HTC = 4, + XR_BODY_JOINT_RIGHT_HIP_HTC = 5, + XR_BODY_JOINT_RIGHT_KNEE_HTC = 6, + XR_BODY_JOINT_RIGHT_ANKLE_HTC = 7, + XR_BODY_JOINT_RIGHT_FEET_HTC = 8, + XR_BODY_JOINT_WAIST_HTC = 9, + XR_BODY_JOINT_SPINE_LOWER_HTC = 10, + XR_BODY_JOINT_SPINE_MIDDLE_HTC = 11, + XR_BODY_JOINT_SPINE_HIGH_HTC = 12, + XR_BODY_JOINT_CHEST_HTC = 13, + XR_BODY_JOINT_NECK_HTC = 14, + XR_BODY_JOINT_HEAD_HTC = 15, + XR_BODY_JOINT_LEFT_CLAVICLE_HTC = 16, + XR_BODY_JOINT_LEFT_SCAPULA_HTC = 17, + XR_BODY_JOINT_LEFT_ARM_HTC = 18, + XR_BODY_JOINT_LEFT_ELBOW_HTC = 19, + XR_BODY_JOINT_LEFT_WRIST_HTC = 20, + XR_BODY_JOINT_RIGHT_CLAVICLE_HTC = 21, + XR_BODY_JOINT_RIGHT_SCAPULA_HTC = 22, + XR_BODY_JOINT_RIGHT_ARM_HTC = 23, + XR_BODY_JOINT_RIGHT_ELBOW_HTC = 24, + XR_BODY_JOINT_RIGHT_WRIST_HTC = 25, + XR_BODY_JOINT_MAX_ENUM_HTC = 0x7FFFFFFF +} XrBodyJointHTC; + +typedef enum XrBodyJointSetHTC { + XR_BODY_JOINT_SET_FULL_HTC = 0, + XR_BODY_JOINT_SET_MAX_ENUM_HTC = 0x7FFFFFFF +} XrBodyJointSetHTC; + +typedef enum XrBodyJointConfidenceHTC { + XR_BODY_JOINT_CONFIDENCE_NONE_HTC = 0, + XR_BODY_JOINT_CONFIDENCE_LOW_HTC = 1, + XR_BODY_JOINT_CONFIDENCE_HIGH_HTC = 2, + XR_BODY_JOINT_CONFIDENCE_MAX_ENUM_HTC = 0x7FFFFFFF +} XrBodyJointConfidenceHTC; +// XrSystemBodyTrackingPropertiesHTC extends XrSystemProperties +typedef struct XrSystemBodyTrackingPropertiesHTC { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsBodyTracking; +} XrSystemBodyTrackingPropertiesHTC; + +typedef struct XrBodyTrackerCreateInfoHTC { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBodyJointSetHTC bodyJointSet; +} XrBodyTrackerCreateInfoHTC; + +typedef struct XrBodyJointsLocateInfoHTC { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace baseSpace; + XrTime time; +} XrBodyJointsLocateInfoHTC; + +typedef struct XrBodyJointLocationHTC { + XrSpaceLocationFlags locationFlags; + XrPosef pose; +} XrBodyJointLocationHTC; + +typedef struct XrBodyJointLocationsHTC { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrSpaceLocationFlags combinedLocationFlags; + XrBodyJointConfidenceHTC confidenceLevel; + uint32_t jointLocationCount; + XrBodyJointLocationHTC* jointLocations; + uint32_t skeletonGenerationId; +} XrBodyJointLocationsHTC; + +typedef struct XrBodySkeletonJointHTC { + XrPosef pose; +} XrBodySkeletonJointHTC; + +typedef struct XrBodySkeletonHTC { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t jointCount; + XrBodySkeletonJointHTC* joints; +} XrBodySkeletonHTC; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateBodyTrackerHTC)(XrSession session, const XrBodyTrackerCreateInfoHTC* createInfo, XrBodyTrackerHTC* bodyTracker); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyBodyTrackerHTC)(XrBodyTrackerHTC bodyTracker); +typedef XrResult (XRAPI_PTR *PFN_xrLocateBodyJointsHTC)(XrBodyTrackerHTC bodyTracker, const XrBodyJointsLocateInfoHTC* locateInfo, XrBodyJointLocationsHTC* locations); +typedef XrResult (XRAPI_PTR *PFN_xrGetBodySkeletonHTC)(XrBodyTrackerHTC bodyTracker, XrSpace baseSpace, uint32_t skeletonGenerationId, XrBodySkeletonHTC* skeleton); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateBodyTrackerHTC( + XrSession session, + const XrBodyTrackerCreateInfoHTC* createInfo, + XrBodyTrackerHTC* bodyTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyBodyTrackerHTC( + XrBodyTrackerHTC bodyTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrLocateBodyJointsHTC( + XrBodyTrackerHTC bodyTracker, + const XrBodyJointsLocateInfoHTC* locateInfo, + XrBodyJointLocationsHTC* locations); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetBodySkeletonHTC( + XrBodyTrackerHTC bodyTracker, + XrSpace baseSpace, + uint32_t skeletonGenerationId, + XrBodySkeletonHTC* skeleton); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_EXT_active_action_set_priority is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_active_action_set_priority 1 +#define XR_EXT_active_action_set_priority_SPEC_VERSION 1 +#define XR_EXT_ACTIVE_ACTION_SET_PRIORITY_EXTENSION_NAME "XR_EXT_active_action_set_priority" +typedef struct XrActiveActionSetPriorityEXT { + XrActionSet actionSet; + uint32_t priorityOverride; +} XrActiveActionSetPriorityEXT; + +// XrActiveActionSetPrioritiesEXT extends XrActionsSyncInfo +typedef struct XrActiveActionSetPrioritiesEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t actionSetPriorityCount; + const XrActiveActionSetPriorityEXT* actionSetPriorities; +} XrActiveActionSetPrioritiesEXT; + + + +// XR_MNDX_force_feedback_curl is a preprocessor guard. Do not pass it to API calls. +#define XR_MNDX_force_feedback_curl 1 +#define XR_MNDX_force_feedback_curl_SPEC_VERSION 1 +#define XR_MNDX_FORCE_FEEDBACK_CURL_EXTENSION_NAME "XR_MNDX_force_feedback_curl" + +typedef enum XrForceFeedbackCurlLocationMNDX { + XR_FORCE_FEEDBACK_CURL_LOCATION_THUMB_CURL_MNDX = 0, + XR_FORCE_FEEDBACK_CURL_LOCATION_INDEX_CURL_MNDX = 1, + XR_FORCE_FEEDBACK_CURL_LOCATION_MIDDLE_CURL_MNDX = 2, + XR_FORCE_FEEDBACK_CURL_LOCATION_RING_CURL_MNDX = 3, + XR_FORCE_FEEDBACK_CURL_LOCATION_LITTLE_CURL_MNDX = 4, + XR_FORCE_FEEDBACK_CURL_LOCATION_MAX_ENUM_MNDX = 0x7FFFFFFF +} XrForceFeedbackCurlLocationMNDX; +// XrSystemForceFeedbackCurlPropertiesMNDX extends XrSystemProperties +typedef struct XrSystemForceFeedbackCurlPropertiesMNDX { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsForceFeedbackCurl; +} XrSystemForceFeedbackCurlPropertiesMNDX; + +typedef struct XrForceFeedbackCurlApplyLocationMNDX { + XrForceFeedbackCurlLocationMNDX location; + float value; +} XrForceFeedbackCurlApplyLocationMNDX; + +typedef struct XrForceFeedbackCurlApplyLocationsMNDX { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t locationCount; + XrForceFeedbackCurlApplyLocationMNDX* locations; +} XrForceFeedbackCurlApplyLocationsMNDX; + +typedef XrResult (XRAPI_PTR *PFN_xrApplyForceFeedbackCurlMNDX)(XrHandTrackerEXT handTracker, const XrForceFeedbackCurlApplyLocationsMNDX* locations); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrApplyForceFeedbackCurlMNDX( + XrHandTrackerEXT handTracker, + const XrForceFeedbackCurlApplyLocationsMNDX* locations); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_BD_controller_interaction is a preprocessor guard. Do not pass it to API calls. +#define XR_BD_controller_interaction 1 +#define XR_BD_controller_interaction_SPEC_VERSION 2 +#define XR_BD_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_BD_controller_interaction" + + +// XR_BD_body_tracking is a preprocessor guard. Do not pass it to API calls. +#define XR_BD_body_tracking 1 + +#define XR_BODY_JOINT_COUNT_BD 24 + + +#define XR_BODY_JOINT_WITHOUT_ARM_COUNT_BD 16 + +XR_DEFINE_HANDLE(XrBodyTrackerBD) +#define XR_BD_body_tracking_SPEC_VERSION 1 +#define XR_BD_BODY_TRACKING_EXTENSION_NAME "XR_BD_body_tracking" + +typedef enum XrBodyJointBD { + XR_BODY_JOINT_PELVIS_BD = 0, + XR_BODY_JOINT_LEFT_HIP_BD = 1, + XR_BODY_JOINT_RIGHT_HIP_BD = 2, + XR_BODY_JOINT_SPINE1_BD = 3, + XR_BODY_JOINT_LEFT_KNEE_BD = 4, + XR_BODY_JOINT_RIGHT_KNEE_BD = 5, + XR_BODY_JOINT_SPINE2_BD = 6, + XR_BODY_JOINT_LEFT_ANKLE_BD = 7, + XR_BODY_JOINT_RIGHT_ANKLE_BD = 8, + XR_BODY_JOINT_SPINE3_BD = 9, + XR_BODY_JOINT_LEFT_FOOT_BD = 10, + XR_BODY_JOINT_RIGHT_FOOT_BD = 11, + XR_BODY_JOINT_NECK_BD = 12, + XR_BODY_JOINT_LEFT_COLLAR_BD = 13, + XR_BODY_JOINT_RIGHT_COLLAR_BD = 14, + XR_BODY_JOINT_HEAD_BD = 15, + XR_BODY_JOINT_LEFT_SHOULDER_BD = 16, + XR_BODY_JOINT_RIGHT_SHOULDER_BD = 17, + XR_BODY_JOINT_LEFT_ELBOW_BD = 18, + XR_BODY_JOINT_RIGHT_ELBOW_BD = 19, + XR_BODY_JOINT_LEFT_WRIST_BD = 20, + XR_BODY_JOINT_RIGHT_WRIST_BD = 21, + XR_BODY_JOINT_LEFT_HAND_BD = 22, + XR_BODY_JOINT_RIGHT_HAND_BD = 23, + XR_BODY_JOINT_MAX_ENUM_BD = 0x7FFFFFFF +} XrBodyJointBD; + +typedef enum XrBodyJointSetBD { + XR_BODY_JOINT_SET_BODY_WITHOUT_ARM_BD = 1, + XR_BODY_JOINT_SET_FULL_BODY_JOINTS_BD = 2, + XR_BODY_JOINT_SET_MAX_ENUM_BD = 0x7FFFFFFF +} XrBodyJointSetBD; +// XrSystemBodyTrackingPropertiesBD extends XrSystemProperties +typedef struct XrSystemBodyTrackingPropertiesBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsBodyTracking; +} XrSystemBodyTrackingPropertiesBD; + +typedef struct XrBodyTrackerCreateInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBodyJointSetBD jointSet; +} XrBodyTrackerCreateInfoBD; + +typedef struct XrBodyJointsLocateInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace baseSpace; + XrTime time; +} XrBodyJointsLocateInfoBD; + +typedef struct XrBodyJointLocationBD { + XrSpaceLocationFlags locationFlags; + XrPosef pose; +} XrBodyJointLocationBD; + +typedef struct XrBodyJointLocationsBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 allJointPosesTracked; + uint32_t jointLocationCount; + XrBodyJointLocationBD* jointLocations; +} XrBodyJointLocationsBD; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateBodyTrackerBD)(XrSession session, const XrBodyTrackerCreateInfoBD* createInfo, XrBodyTrackerBD* bodyTracker); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyBodyTrackerBD)(XrBodyTrackerBD bodyTracker); +typedef XrResult (XRAPI_PTR *PFN_xrLocateBodyJointsBD)(XrBodyTrackerBD bodyTracker, const XrBodyJointsLocateInfoBD* locateInfo, XrBodyJointLocationsBD* locations); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateBodyTrackerBD( + XrSession session, + const XrBodyTrackerCreateInfoBD* createInfo, + XrBodyTrackerBD* bodyTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyBodyTrackerBD( + XrBodyTrackerBD bodyTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrLocateBodyJointsBD( + XrBodyTrackerBD bodyTracker, + const XrBodyJointsLocateInfoBD* locateInfo, + XrBodyJointLocationsBD* locations); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_BD_facial_simulation is a preprocessor guard. Do not pass it to API calls. +#define XR_BD_facial_simulation 1 + +#define XR_FACE_EXPRESSION_COUNT_BD 52 + + +#define XR_LIP_EXPRESSION_COUNT_BD 20 + + XR_DEFINE_HANDLE(XrFaceTrackerBD) +#define XR_BD_facial_simulation_SPEC_VERSION 1 +#define XR_BD_FACIAL_SIMULATION_EXTENSION_NAME "XR_BD_facial_simulation" + +typedef enum XrFacialSimulationModeBD { + XR_FACIAL_SIMULATION_MODE_DEFAULT_BD = 0, + XR_FACIAL_SIMULATION_MODE_COMBINED_AUDIO_BD = 1, + XR_FACIAL_SIMULATION_MODE_COMBINED_AUDIO_WITH_LIP_BD = 2, + XR_FACIAL_SIMULATION_MODE_ONLY_AUDIO_WITH_LIP_BD = 3, + XR_FACIAL_SIMULATION_MODE_MAX_ENUM_BD = 0x7FFFFFFF +} XrFacialSimulationModeBD; + +typedef enum XrFaceExpressionBD { + XR_FACE_EXPRESSION_BROW_DROP_L_BD = 0, + XR_FACE_EXPRESSION_BROW_DROP_R_BD = 1, + XR_FACE_EXPRESSION_BROW_INNER_UPWARDS_BD = 2, + XR_FACE_EXPRESSION_BROW_OUTER_UPWARDS_L_BD = 3, + XR_FACE_EXPRESSION_BROW_OUTER_UPWARDS_R_BD = 4, + XR_FACE_EXPRESSION_EYE_BLINK_L_BD = 5, + XR_FACE_EXPRESSION_EYE_LOOK_DROP_L_BD = 6, + XR_FACE_EXPRESSION_EYE_LOOK_IN_L_BD = 7, + XR_FACE_EXPRESSION_EYE_LOOK_OUT_L_BD = 8, + XR_FACE_EXPRESSION_EYE_LOOK_UPWARDS_L_BD = 9, + XR_FACE_EXPRESSION_EYE_LOOK_SQUINT_L_BD = 10, + XR_FACE_EXPRESSION_EYE_LOOK_WIDE_L_BD = 11, + XR_FACE_EXPRESSION_EYE_BLINK_R_BD = 12, + XR_FACE_EXPRESSION_EYE_LOOK_DROP_R_BD = 13, + XR_FACE_EXPRESSION_EYE_LOOK_IN_R_BD = 14, + XR_FACE_EXPRESSION_EYE_LOOK_OUT_R_BD = 15, + XR_FACE_EXPRESSION_EYE_LOOK_UPWARDS_R_BD = 16, + XR_FACE_EXPRESSION_EYE_LOOK_SQUINT_R_BD = 17, + XR_FACE_EXPRESSION_EYE_LOOK_WIDE_R_BD = 18, + XR_FACE_EXPRESSION_NOSE_SNEER_L_BD = 19, + XR_FACE_EXPRESSION_NOSE_SNEER_R_BD = 20, + XR_FACE_EXPRESSION_CHEEK_PUFF_BD = 21, + XR_FACE_EXPRESSION_CHEEK_SQUINT_L_BD = 22, + XR_FACE_EXPRESSION_CHEEK_SQUINT_R_BD = 23, + XR_FACE_EXPRESSION_MOUTH_CLOSE_BD = 24, + XR_FACE_EXPRESSION_MOUTH_FUNNEL_BD = 25, + XR_FACE_EXPRESSION_MOUTH_PUCKER_BD = 26, + XR_FACE_EXPRESSION_MOUTH_L_BD = 27, + XR_FACE_EXPRESSION_MOUTH_R_BD = 28, + XR_FACE_EXPRESSION_MOUTH_SMILE_L_BD = 29, + XR_FACE_EXPRESSION_MOUTH_SMILE_R_BD = 30, + XR_FACE_EXPRESSION_MOUTH_FROWN_L_BD = 31, + XR_FACE_EXPRESSION_MOUTH_FROWN_R_BD = 32, + XR_FACE_EXPRESSION_MOUTH_DIMPLE_L_BD = 33, + XR_FACE_EXPRESSION_MOUTH_DIMPLE_R_BD = 34, + XR_FACE_EXPRESSION_MOUTH_STRETCH_L_BD = 35, + XR_FACE_EXPRESSION_MOUTH_STRETCH_R_BD = 36, + XR_FACE_EXPRESSION_MOUTH_ROLL_LOWER_BD = 37, + XR_FACE_EXPRESSION_MOUTH_ROLL_UPPER_BD = 38, + XR_FACE_EXPRESSION_MOUTH_SHRUG_LOWER_BD = 39, + XR_FACE_EXPRESSION_MOUTH_SHRUG_UPPER_BD = 40, + XR_FACE_EXPRESSION_MOUTH_PRESS_L_BD = 41, + XR_FACE_EXPRESSION_MOUTH_PRESS_R_BD = 42, + XR_FACE_EXPRESSION_MOUTH_LOWER_DROP_L_BD = 43, + XR_FACE_EXPRESSION_MOUTH_LOWER_DROP_R_BD = 44, + XR_FACE_EXPRESSION_MOUTH_UPPER_UPWARDS_L_BD = 45, + XR_FACE_EXPRESSION_MOUTH_UPPER_UPWARDS_R_BD = 46, + XR_FACE_EXPRESSION_JAW_FORWARD_BD = 47, + XR_FACE_EXPRESSION_JAW_L_BD = 48, + XR_FACE_EXPRESSION_JAW_R_BD = 49, + XR_FACE_EXPRESSION_JAW_OPEN_BD = 50, + XR_FACE_EXPRESSION_TONGUE_OUT_BD = 51, + XR_FACE_EXPRESSION_MAX_ENUM_BD = 0x7FFFFFFF +} XrFaceExpressionBD; + +typedef enum XrLipExpressionBD { + XR_LIP_EXPRESSION_PP_BD = 0, + XR_LIP_EXPRESSION_CH_BD = 1, + XR_LIP_EXPRESSION_LO_BD = 2, + XR_LIP_EXPRESSION_O_BD = 3, + XR_LIP_EXPRESSION_I_BD = 4, + XR_LIP_EXPRESSION_LU_BD = 5, + XR_LIP_EXPRESSION_RR_BD = 6, + XR_LIP_EXPRESSION_XX_BD = 7, + XR_LIP_EXPRESSION_LAA_BD = 8, + XR_LIP_EXPRESSION_LI_BD = 9, + XR_LIP_EXPRESSION_FF_BD = 10, + XR_LIP_EXPRESSION_U_BD = 11, + XR_LIP_EXPRESSION_TH_BD = 12, + XR_LIP_EXPRESSION_LKK_BD = 13, + XR_LIP_EXPRESSION_SS_BD = 14, + XR_LIP_EXPRESSION_LE_BD = 15, + XR_LIP_EXPRESSION_DD_BD = 16, + XR_LIP_EXPRESSION_E_BD = 17, + XR_LIP_EXPRESSION_LNN_BD = 18, + XR_LIP_EXPRESSION_SIL_BD = 19, + XR_LIP_EXPRESSION_MAX_ENUM_BD = 0x7FFFFFFF +} XrLipExpressionBD; +// XrSystemFacialSimulationPropertiesBD extends XrSystemProperties +typedef struct XrSystemFacialSimulationPropertiesBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsFaceTracking; +} XrSystemFacialSimulationPropertiesBD; + +typedef struct XrFaceTrackerCreateInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrFacialSimulationModeBD mode; +} XrFaceTrackerCreateInfoBD; + +typedef struct XrFacialSimulationDataGetInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrTime time; +} XrFacialSimulationDataGetInfoBD; + +typedef struct XrFacialSimulationDataBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t faceExpressionWeightCount; + float* faceExpressionWeights; + XrBool32 isUpperFaceDataValid; + XrBool32 isLowerFaceDataValid; + XrTime time; +} XrFacialSimulationDataBD; + +// XrLipExpressionDataBD extends XrFacialSimulationDataBD +typedef struct XrLipExpressionDataBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t lipsyncExpressionWeightCount; + float* lipsyncExpressionWeights; +} XrLipExpressionDataBD; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateFacialSimulationModesBD)(XrSession session, uint32_t modeCapacityInput, uint32_t* modeCountOutput, XrFacialSimulationModeBD* modes); +typedef XrResult (XRAPI_PTR *PFN_xrCreateFaceTrackerBD)(XrSession session, const XrFaceTrackerCreateInfoBD* createInfo, XrFaceTrackerBD* tracker); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyFaceTrackerBD)(XrFaceTrackerBD tracker); +typedef XrResult (XRAPI_PTR *PFN_xrGetFacialSimulationDataBD)(XrFaceTrackerBD tracker, const XrFacialSimulationDataGetInfoBD*info, XrFacialSimulationDataBD* facialData); +typedef XrResult (XRAPI_PTR *PFN_xrSetFacialSimulationModeBD)(XrFaceTrackerBD tracker, XrFacialSimulationModeBD mode); +typedef XrResult (XRAPI_PTR *PFN_xrGetFacialSimulationModeBD)(XrFaceTrackerBD tracker, XrFacialSimulationModeBD*mode); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateFacialSimulationModesBD( + XrSession session, + uint32_t modeCapacityInput, + uint32_t* modeCountOutput, + XrFacialSimulationModeBD* modes); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateFaceTrackerBD( + XrSession session, + const XrFaceTrackerCreateInfoBD* createInfo, + XrFaceTrackerBD* tracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyFaceTrackerBD( + XrFaceTrackerBD tracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetFacialSimulationDataBD( + XrFaceTrackerBD tracker, + const XrFacialSimulationDataGetInfoBD* info, + XrFacialSimulationDataBD* facialData); + +XRAPI_ATTR XrResult XRAPI_CALL xrSetFacialSimulationModeBD( + XrFaceTrackerBD tracker, + XrFacialSimulationModeBD mode); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetFacialSimulationModeBD( + XrFaceTrackerBD tracker, + XrFacialSimulationModeBD* mode); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_BD_spatial_sensing is a preprocessor guard. Do not pass it to API calls. +#define XR_BD_spatial_sensing 1 +XR_DEFINE_ATOM(XrSpatialEntityIdBD) +XR_DEFINE_HANDLE(XrSenseDataProviderBD) +XR_DEFINE_HANDLE(XrSenseDataSnapshotBD) +XR_DEFINE_HANDLE(XrAnchorBD) +#define XR_BD_spatial_sensing_SPEC_VERSION 3 +#define XR_BD_SPATIAL_SENSING_EXTENSION_NAME "XR_BD_spatial_sensing" + +typedef enum XrSpatialEntityComponentTypeBD { + XR_SPATIAL_ENTITY_COMPONENT_TYPE_LOCATION_BD = 0, + XR_SPATIAL_ENTITY_COMPONENT_TYPE_SEMANTIC_BD = 1, + XR_SPATIAL_ENTITY_COMPONENT_TYPE_BOUNDING_BOX_2D_BD = 2, + XR_SPATIAL_ENTITY_COMPONENT_TYPE_POLYGON_BD = 3, + XR_SPATIAL_ENTITY_COMPONENT_TYPE_BOUNDING_BOX_3D_BD = 4, + XR_SPATIAL_ENTITY_COMPONENT_TYPE_TRIANGLE_MESH_BD = 5, + XR_SPATIAL_ENTITY_COMPONENT_TYPE_SPHERE_BD = 6, + XR_SPATIAL_ENTITY_COMPONENT_TYPE_PLANE_ORIENTATION_BD = 1000396000, + XR_SPATIAL_ENTITY_COMPONENT_TYPE_LIGHT_ESTIMATION_BD = 1000397000, + XR_SPATIAL_ENTITY_COMPONENT_TYPE_DYNAMIC_OBJECT_BD = 1000746000, + XR_SPATIAL_ENTITY_COMPONENT_TYPE_MAX_ENUM_BD = 0x7FFFFFFF +} XrSpatialEntityComponentTypeBD; + +typedef enum XrSemanticLabelBD { + XR_SEMANTIC_LABEL_UNKNOWN_BD = 0, + XR_SEMANTIC_LABEL_FLOOR_BD = 1, + XR_SEMANTIC_LABEL_CEILING_BD = 2, + XR_SEMANTIC_LABEL_WALL_BD = 3, + XR_SEMANTIC_LABEL_DOOR_BD = 4, + XR_SEMANTIC_LABEL_WINDOW_BD = 5, + XR_SEMANTIC_LABEL_OPENING_BD = 6, + XR_SEMANTIC_LABEL_TABLE_BD = 7, + XR_SEMANTIC_LABEL_SOFA_BD = 8, + XR_SEMANTIC_LABEL_CHAIR_BD = 9, + XR_SEMANTIC_LABEL_HUMAN_BD = 10, + XR_SEMANTIC_LABEL_BEAM_BD = 11, + XR_SEMANTIC_LABEL_COLUMN_BD = 12, + XR_SEMANTIC_LABEL_CURTAIN_BD = 13, + XR_SEMANTIC_LABEL_CABINET_BD = 14, + XR_SEMANTIC_LABEL_BED_BD = 15, + XR_SEMANTIC_LABEL_PLANT_BD = 16, + XR_SEMANTIC_LABEL_SCREEN_BD = 17, + XR_SEMANTIC_LABEL_VIRTUAL_WALL_BD = 18, + XR_SEMANTIC_LABEL_REFRIGERATOR_BD = 19, + XR_SEMANTIC_LABEL_WASHING_MACHINE_BD = 20, + XR_SEMANTIC_LABEL_AIR_CONDITIONER_BD = 21, + XR_SEMANTIC_LABEL_LAMP_BD = 22, + XR_SEMANTIC_LABEL_WALL_ART_BD = 23, + XR_SEMANTIC_LABEL_STAIRWAY_BD = 24, + XR_SEMANTIC_LABEL_KEYBOARD_BD = 25, + XR_SEMANTIC_LABEL_MOUSE_BD = 26, + XR_SEMANTIC_LABEL_LAPTOP_BD = 27, + XR_SEMANTIC_LABEL_MAX_ENUM_BD = 0x7FFFFFFF +} XrSemanticLabelBD; + +typedef enum XrSenseDataProviderTypeBD { + XR_SENSE_DATA_PROVIDER_TYPE_ANCHOR_BD = 1000390000, + XR_SENSE_DATA_PROVIDER_TYPE_SCENE_BD = 1000392000, + XR_SENSE_DATA_PROVIDER_TYPE_MESH_BD = 1000393000, + XR_SENSE_DATA_PROVIDER_TYPE_PLANE_BD = 1000396000, + XR_SENSE_DATA_PROVIDER_TYPE_LIGHT_ESTIMATION_BD = 1000397000, + XR_SENSE_DATA_PROVIDER_TYPE_DYNAMIC_OBJECT_BD = 1000746000, + XR_SENSE_DATA_PROVIDER_TYPE_MAX_ENUM_BD = 0x7FFFFFFF +} XrSenseDataProviderTypeBD; + +typedef enum XrSenseDataProviderStateBD { + XR_SENSE_DATA_PROVIDER_STATE_INITIALIZED_BD = 0, + XR_SENSE_DATA_PROVIDER_STATE_RUNNING_BD = 1, + XR_SENSE_DATA_PROVIDER_STATE_STOPPED_BD = 2, + XR_SENSE_DATA_PROVIDER_STATE_MAX_ENUM_BD = 0x7FFFFFFF +} XrSenseDataProviderStateBD; +// XrSystemSpatialSensingPropertiesBD extends XrSystemProperties +typedef struct XrSystemSpatialSensingPropertiesBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsSpatialSensing; +} XrSystemSpatialSensingPropertiesBD; + +typedef struct XrSpatialEntityComponentGetInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialEntityIdBD entityId; + XrSpatialEntityComponentTypeBD componentType; +} XrSpatialEntityComponentGetInfoBD; + +typedef struct XrSpatialEntityComponentDataBaseHeaderBD { + XrStructureType type; + void* XR_MAY_ALIAS next; +} XrSpatialEntityComponentDataBaseHeaderBD; + +// XrSpatialEntityLocationGetInfoBD extends XrSpatialEntityComponentGetInfoBD +typedef struct XrSpatialEntityLocationGetInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace baseSpace; +} XrSpatialEntityLocationGetInfoBD; + +// XrSpatialEntityComponentDataLocationBD extends XrSpatialEntityComponentDataBaseHeaderBD +typedef struct XrSpatialEntityComponentDataLocationBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrSpaceLocation location; +} XrSpatialEntityComponentDataLocationBD; + +// XrSpatialEntityComponentDataSemanticBD extends XrSpatialEntityComponentDataBaseHeaderBD +typedef struct XrSpatialEntityComponentDataSemanticBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t labelCapacityInput; + uint32_t labelCountOutput; + XrSemanticLabelBD* labels; +} XrSpatialEntityComponentDataSemanticBD; + +// XrSpatialEntityComponentDataBoundingBox2DBD extends XrSpatialEntityComponentDataBaseHeaderBD +typedef struct XrSpatialEntityComponentDataBoundingBox2DBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrRect2Df boundingBox2D; +} XrSpatialEntityComponentDataBoundingBox2DBD; + +// XrSpatialEntityComponentDataPolygonBD extends XrSpatialEntityComponentDataBaseHeaderBD +typedef struct XrSpatialEntityComponentDataPolygonBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t vertexCapacityInput; + uint32_t vertexCountOutput; + XrVector2f* vertices; +} XrSpatialEntityComponentDataPolygonBD; + +// XrSpatialEntityComponentDataBoundingBox3DBD extends XrSpatialEntityComponentDataBaseHeaderBD +typedef struct XrSpatialEntityComponentDataBoundingBox3DBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBoxf boundingBox3D; +} XrSpatialEntityComponentDataBoundingBox3DBD; + +// XrSpatialEntityComponentDataTriangleMeshBD extends XrSpatialEntityComponentDataBaseHeaderBD +typedef struct XrSpatialEntityComponentDataTriangleMeshBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t vertexCapacityInput; + uint32_t vertexCountOutput; + XrVector3f* vertices; + uint32_t indexCapacityInput; + uint32_t indexCountOutput; + uint16_t* indices; +} XrSpatialEntityComponentDataTriangleMeshBD; + +// XrSpatialEntityComponentDataSphereBD extends XrSpatialEntityComponentDataBaseHeaderBD +typedef struct XrSpatialEntityComponentDataSphereBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrSpheref sphere; +} XrSpatialEntityComponentDataSphereBD; + +typedef struct XrSenseDataProviderCreateInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSenseDataProviderTypeBD providerType; +} XrSenseDataProviderCreateInfoBD; + +typedef struct XrSenseDataProviderStartInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrSenseDataProviderStartInfoBD; + +typedef struct XrEventDataSenseDataProviderStateChangedBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSenseDataProviderBD provider; + XrSenseDataProviderStateBD newState; +} XrEventDataSenseDataProviderStateChangedBD; + +typedef struct XrEventDataSenseDataUpdatedBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSenseDataProviderBD provider; +} XrEventDataSenseDataUpdatedBD; + +typedef struct XrSenseDataQueryInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrSenseDataQueryInfoBD; + +typedef struct XrSenseDataQueryCompletionBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrResult futureResult; + XrSenseDataSnapshotBD snapshot; +} XrSenseDataQueryCompletionBD; + +typedef struct XrQueriedSenseDataGetInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrQueriedSenseDataGetInfoBD; + +typedef struct XrSpatialEntityStateBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrSpatialEntityIdBD entityId; + XrTime lastUpdateTime; + XrUuidEXT uuid; +} XrSpatialEntityStateBD; + +typedef struct XrQueriedSenseDataBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t stateCapacityInput; + uint32_t stateCountOutput; + XrSpatialEntityStateBD* states; +} XrQueriedSenseDataBD; + +// XrSenseDataFilterUuidBD extends XrSenseDataQueryInfoBD +typedef struct XrSenseDataFilterUuidBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t uuidCount; + const XrUuidEXT* uuids; +} XrSenseDataFilterUuidBD; + +// XrSenseDataFilterSemanticBD extends XrSenseDataQueryInfoBD +typedef struct XrSenseDataFilterSemanticBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t labelCount; + const XrSemanticLabelBD* labels; +} XrSenseDataFilterSemanticBD; + +typedef struct XrSpatialEntityAnchorCreateInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSenseDataSnapshotBD snapshot; + XrSpatialEntityIdBD entityId; +} XrSpatialEntityAnchorCreateInfoBD; + +typedef struct XrAnchorSpaceCreateInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAnchorBD anchor; + XrPosef poseInAnchorSpace; +} XrAnchorSpaceCreateInfoBD; + +typedef struct XrFutureCompletionEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrResult futureResult; +} XrFutureCompletionEXT; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSpatialEntityComponentTypesBD)(XrSenseDataSnapshotBD snapshot, XrSpatialEntityIdBD entityId, uint32_t componentTypeCapacityInput, uint32_t* componentTypeCountOutput, XrSpatialEntityComponentTypeBD* componentTypes); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialEntityUuidBD)(XrSenseDataSnapshotBD snapshot, XrSpatialEntityIdBD entityId, XrUuidEXT* uuid); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialEntityComponentDataBD)(XrSenseDataSnapshotBD snapshot, const XrSpatialEntityComponentGetInfoBD* getInfo, XrSpatialEntityComponentDataBaseHeaderBD* componentData); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSenseDataProviderBD)(XrSession session, const XrSenseDataProviderCreateInfoBD* createInfo, XrSenseDataProviderBD* provider); +typedef XrResult (XRAPI_PTR *PFN_xrStartSenseDataProviderAsyncBD)(XrSenseDataProviderBD provider, const XrSenseDataProviderStartInfoBD* startInfo, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrStartSenseDataProviderCompleteBD)(XrSession session, XrFutureEXT future, XrFutureCompletionEXT* completion); +typedef XrResult (XRAPI_PTR *PFN_xrGetSenseDataProviderStateBD)(XrSenseDataProviderBD provider, XrSenseDataProviderStateBD* state); +typedef XrResult (XRAPI_PTR *PFN_xrQuerySenseDataAsyncBD)(XrSenseDataProviderBD provider, const XrSenseDataQueryInfoBD* queryInfo, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrQuerySenseDataCompleteBD)(XrSenseDataProviderBD provider, XrFutureEXT future, XrSenseDataQueryCompletionBD* completion); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySenseDataSnapshotBD)(XrSenseDataSnapshotBD snapshot); +typedef XrResult (XRAPI_PTR *PFN_xrGetQueriedSenseDataBD)(XrSenseDataSnapshotBD snapshot, XrQueriedSenseDataGetInfoBD* getInfo, XrQueriedSenseDataBD* queriedSenseData); +typedef XrResult (XRAPI_PTR *PFN_xrStopSenseDataProviderBD)(XrSenseDataProviderBD provider); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySenseDataProviderBD)(XrSenseDataProviderBD provider); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialEntityAnchorBD)(XrSenseDataProviderBD provider, const XrSpatialEntityAnchorCreateInfoBD* createInfo, XrAnchorBD* anchor); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyAnchorBD)(XrAnchorBD anchor); +typedef XrResult (XRAPI_PTR *PFN_xrGetAnchorUuidBD)(XrAnchorBD anchor, XrUuidEXT* uuid); +typedef XrResult (XRAPI_PTR *PFN_xrCreateAnchorSpaceBD)(XrSession session, const XrAnchorSpaceCreateInfoBD* createInfo, XrSpace* space); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSpatialEntityComponentTypesBD( + XrSenseDataSnapshotBD snapshot, + XrSpatialEntityIdBD entityId, + uint32_t componentTypeCapacityInput, + uint32_t* componentTypeCountOutput, + XrSpatialEntityComponentTypeBD* componentTypes); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialEntityUuidBD( + XrSenseDataSnapshotBD snapshot, + XrSpatialEntityIdBD entityId, + XrUuidEXT* uuid); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialEntityComponentDataBD( + XrSenseDataSnapshotBD snapshot, + const XrSpatialEntityComponentGetInfoBD* getInfo, + XrSpatialEntityComponentDataBaseHeaderBD* componentData); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSenseDataProviderBD( + XrSession session, + const XrSenseDataProviderCreateInfoBD* createInfo, + XrSenseDataProviderBD* provider); + +XRAPI_ATTR XrResult XRAPI_CALL xrStartSenseDataProviderAsyncBD( + XrSenseDataProviderBD provider, + const XrSenseDataProviderStartInfoBD* startInfo, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrStartSenseDataProviderCompleteBD( + XrSession session, + XrFutureEXT future, + XrFutureCompletionEXT* completion); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSenseDataProviderStateBD( + XrSenseDataProviderBD provider, + XrSenseDataProviderStateBD* state); + +XRAPI_ATTR XrResult XRAPI_CALL xrQuerySenseDataAsyncBD( + XrSenseDataProviderBD provider, + const XrSenseDataQueryInfoBD* queryInfo, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrQuerySenseDataCompleteBD( + XrSenseDataProviderBD provider, + XrFutureEXT future, + XrSenseDataQueryCompletionBD* completion); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySenseDataSnapshotBD( + XrSenseDataSnapshotBD snapshot); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetQueriedSenseDataBD( + XrSenseDataSnapshotBD snapshot, + XrQueriedSenseDataGetInfoBD* getInfo, + XrQueriedSenseDataBD* queriedSenseData); + +XRAPI_ATTR XrResult XRAPI_CALL xrStopSenseDataProviderBD( + XrSenseDataProviderBD provider); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySenseDataProviderBD( + XrSenseDataProviderBD provider); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialEntityAnchorBD( + XrSenseDataProviderBD provider, + const XrSpatialEntityAnchorCreateInfoBD* createInfo, + XrAnchorBD* anchor); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyAnchorBD( + XrAnchorBD anchor); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetAnchorUuidBD( + XrAnchorBD anchor, + XrUuidEXT* uuid); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateAnchorSpaceBD( + XrSession session, + const XrAnchorSpaceCreateInfoBD* createInfo, + XrSpace* space); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_BD_spatial_anchor is a preprocessor guard. Do not pass it to API calls. +#define XR_BD_spatial_anchor 1 +#define XR_BD_spatial_anchor_SPEC_VERSION 2 +#define XR_BD_SPATIAL_ANCHOR_EXTENSION_NAME "XR_BD_spatial_anchor" + +typedef enum XrPersistenceLocationBD { + XR_PERSISTENCE_LOCATION_LOCAL_BD = 0, + XR_PERSISTENCE_LOCATION_MAX_ENUM_BD = 0x7FFFFFFF +} XrPersistenceLocationBD; +// XrSystemSpatialAnchorPropertiesBD extends XrSystemProperties +typedef struct XrSystemSpatialAnchorPropertiesBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsSpatialAnchor; +} XrSystemSpatialAnchorPropertiesBD; + +typedef struct XrSpatialAnchorCreateInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace space; + XrPosef pose; + XrTime time; +} XrSpatialAnchorCreateInfoBD; + +typedef struct XrSpatialAnchorCreateCompletionBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrResult futureResult; + XrUuidEXT uuid; + XrAnchorBD anchor; +} XrSpatialAnchorCreateCompletionBD; + +typedef struct XrSpatialAnchorPersistInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPersistenceLocationBD location; + XrAnchorBD anchor; +} XrSpatialAnchorPersistInfoBD; + +typedef struct XrSpatialAnchorUnpersistInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPersistenceLocationBD location; + XrAnchorBD anchor; +} XrSpatialAnchorUnpersistInfoBD; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorAsyncBD)(XrSenseDataProviderBD provider, const XrSpatialAnchorCreateInfoBD* info, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorCompleteBD)(XrSenseDataProviderBD provider, XrFutureEXT future, XrSpatialAnchorCreateCompletionBD* completion); +typedef XrResult (XRAPI_PTR *PFN_xrPersistSpatialAnchorAsyncBD)(XrSenseDataProviderBD provider, const XrSpatialAnchorPersistInfoBD* info, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrPersistSpatialAnchorCompleteBD)(XrSenseDataProviderBD provider, XrFutureEXT future, XrFutureCompletionEXT* completion); +typedef XrResult (XRAPI_PTR *PFN_xrUnpersistSpatialAnchorAsyncBD)(XrSenseDataProviderBD provider, const XrSpatialAnchorUnpersistInfoBD* info, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrUnpersistSpatialAnchorCompleteBD)(XrSenseDataProviderBD provider, XrFutureEXT future, XrFutureCompletionEXT* completion); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorAsyncBD( + XrSenseDataProviderBD provider, + const XrSpatialAnchorCreateInfoBD* info, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorCompleteBD( + XrSenseDataProviderBD provider, + XrFutureEXT future, + XrSpatialAnchorCreateCompletionBD* completion); + +XRAPI_ATTR XrResult XRAPI_CALL xrPersistSpatialAnchorAsyncBD( + XrSenseDataProviderBD provider, + const XrSpatialAnchorPersistInfoBD* info, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrPersistSpatialAnchorCompleteBD( + XrSenseDataProviderBD provider, + XrFutureEXT future, + XrFutureCompletionEXT* completion); + +XRAPI_ATTR XrResult XRAPI_CALL xrUnpersistSpatialAnchorAsyncBD( + XrSenseDataProviderBD provider, + const XrSpatialAnchorUnpersistInfoBD* info, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrUnpersistSpatialAnchorCompleteBD( + XrSenseDataProviderBD provider, + XrFutureEXT future, + XrFutureCompletionEXT* completion); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_BD_spatial_anchor_sharing is a preprocessor guard. Do not pass it to API calls. +#define XR_BD_spatial_anchor_sharing 1 +#define XR_BD_spatial_anchor_sharing_SPEC_VERSION 2 +#define XR_BD_SPATIAL_ANCHOR_SHARING_EXTENSION_NAME "XR_BD_spatial_anchor_sharing" +// XrSystemSpatialAnchorSharingPropertiesBD extends XrSystemProperties +typedef struct XrSystemSpatialAnchorSharingPropertiesBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsSpatialAnchorSharing; +} XrSystemSpatialAnchorSharingPropertiesBD; + +typedef struct XrSpatialAnchorShareInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAnchorBD anchor; +} XrSpatialAnchorShareInfoBD; + +typedef struct XrSharedSpatialAnchorDownloadInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrUuidEXT uuid; +} XrSharedSpatialAnchorDownloadInfoBD; + +typedef XrResult (XRAPI_PTR *PFN_xrShareSpatialAnchorAsyncBD)(XrSenseDataProviderBD provider, const XrSpatialAnchorShareInfoBD* info, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrShareSpatialAnchorCompleteBD)(XrSenseDataProviderBD provider, XrFutureEXT future, XrFutureCompletionEXT* completion); +typedef XrResult (XRAPI_PTR *PFN_xrDownloadSharedSpatialAnchorAsyncBD)(XrSenseDataProviderBD provider, const XrSharedSpatialAnchorDownloadInfoBD* info, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrDownloadSharedSpatialAnchorCompleteBD)(XrSenseDataProviderBD provider, XrFutureEXT future, XrFutureCompletionEXT* completion); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrShareSpatialAnchorAsyncBD( + XrSenseDataProviderBD provider, + const XrSpatialAnchorShareInfoBD* info, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrShareSpatialAnchorCompleteBD( + XrSenseDataProviderBD provider, + XrFutureEXT future, + XrFutureCompletionEXT* completion); + +XRAPI_ATTR XrResult XRAPI_CALL xrDownloadSharedSpatialAnchorAsyncBD( + XrSenseDataProviderBD provider, + const XrSharedSpatialAnchorDownloadInfoBD* info, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrDownloadSharedSpatialAnchorCompleteBD( + XrSenseDataProviderBD provider, + XrFutureEXT future, + XrFutureCompletionEXT* completion); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_BD_spatial_scene is a preprocessor guard. Do not pass it to API calls. +#define XR_BD_spatial_scene 1 +#define XR_BD_spatial_scene_SPEC_VERSION 1 +#define XR_BD_SPATIAL_SCENE_EXTENSION_NAME "XR_BD_spatial_scene" +// XrSystemSpatialScenePropertiesBD extends XrSystemProperties +typedef struct XrSystemSpatialScenePropertiesBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsSpatialScene; +} XrSystemSpatialScenePropertiesBD; + +typedef struct XrSceneCaptureInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrSceneCaptureInfoBD; + +typedef XrResult (XRAPI_PTR *PFN_xrCaptureSceneAsyncBD)(XrSenseDataProviderBD provider, const XrSceneCaptureInfoBD* info, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrCaptureSceneCompleteBD)(XrSenseDataProviderBD provider, XrFutureEXT future, XrFutureCompletionEXT* completion); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCaptureSceneAsyncBD( + XrSenseDataProviderBD provider, + const XrSceneCaptureInfoBD* info, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrCaptureSceneCompleteBD( + XrSenseDataProviderBD provider, + XrFutureEXT future, + XrFutureCompletionEXT* completion); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_BD_spatial_mesh is a preprocessor guard. Do not pass it to API calls. +#define XR_BD_spatial_mesh 1 +#define XR_BD_spatial_mesh_SPEC_VERSION 1 +#define XR_BD_SPATIAL_MESH_EXTENSION_NAME "XR_BD_spatial_mesh" + +typedef enum XrSpatialMeshLodBD { + XR_SPATIAL_MESH_LOD_COARSE_BD = 0, + XR_SPATIAL_MESH_LOD_MEDIUM_BD = 1, + XR_SPATIAL_MESH_LOD_FINE_BD = 2, + XR_SPATIAL_MESH_LOD_MAX_ENUM_BD = 0x7FFFFFFF +} XrSpatialMeshLodBD; +typedef XrFlags64 XrSpatialMeshConfigFlagsBD; + +// Flag bits for XrSpatialMeshConfigFlagsBD +static const XrSpatialMeshConfigFlagsBD XR_SPATIAL_MESH_CONFIG_SEMANTIC_BIT_BD = 0x00000001; +static const XrSpatialMeshConfigFlagsBD XR_SPATIAL_MESH_CONFIG_ALIGN_SEMANTIC_WITH_VERTEX_BIT_BD = 0x00000002; + +// XrSystemSpatialMeshPropertiesBD extends XrSystemProperties +typedef struct XrSystemSpatialMeshPropertiesBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsSpatialMesh; +} XrSystemSpatialMeshPropertiesBD; + +// XrSenseDataProviderCreateInfoSpatialMeshBD extends XrSenseDataProviderCreateInfoBD +typedef struct XrSenseDataProviderCreateInfoSpatialMeshBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialMeshConfigFlagsBD configFlags; + XrSpatialMeshLodBD lod; +} XrSenseDataProviderCreateInfoSpatialMeshBD; + + + +// XR_BD_future_progress is a preprocessor guard. Do not pass it to API calls. +#define XR_BD_future_progress 1 +#define XR_BD_future_progress_SPEC_VERSION 1 +#define XR_BD_FUTURE_PROGRESS_EXTENSION_NAME "XR_BD_future_progress" +// XrFuturePollResultProgressBD extends XrFuturePollResultEXT +typedef struct XrFuturePollResultProgressBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 isSupported; + uint32_t progressPercentage; +} XrFuturePollResultProgressBD; + + + +// XR_BD_body_tracking_auxiliary_metrics is a preprocessor guard. Do not pass it to API calls. +#define XR_BD_body_tracking_auxiliary_metrics 1 +#define XR_BD_body_tracking_auxiliary_metrics_SPEC_VERSION 1 +#define XR_BD_BODY_TRACKING_AUXILIARY_METRICS_EXTENSION_NAME "XR_BD_body_tracking_auxiliary_metrics" + +typedef enum XrBodyTrackingPostureBD { + XR_BODY_TRACKING_POSTURE_STOMP_BD = 1, + XR_BODY_TRACKING_POSTURE_STATIC_BD = 2, + XR_BODY_TRACKING_POSTURE_MAX_ENUM_BD = 0x7FFFFFFF +} XrBodyTrackingPostureBD; + +typedef enum XrBodyTrackingStatusBD { + XR_BODY_TRACKING_STATUS_INVALID_BD = 0, + XR_BODY_TRACKING_STATUS_VALID_BD = 1, + XR_BODY_TRACKING_STATUS_LIMITED_BD = 2, + XR_BODY_TRACKING_STATUS_MAX_ENUM_BD = 0x7FFFFFFF +} XrBodyTrackingStatusBD; + +typedef enum XrBodyTrackingMessageBD { + XR_BODY_TRACKING_MESSAGE_NO_ERROR_BD = 0, + XR_BODY_TRACKING_MESSAGE_TRACKER_NOT_CALIBRATED_BD = 1, + XR_BODY_TRACKING_MESSAGE_TRACKER_NUM_NOT_ENOUGH_BD = 2, + XR_BODY_TRACKING_MESSAGE_TRACKER_STATE_NOT_SATISFIED_BD = 3, + XR_BODY_TRACKING_MESSAGE_TRACKER_PERSISTENT_INVISIBILITY_BD = 4, + XR_BODY_TRACKING_MESSAGE_TRACKER_DATA_ERROR_BD = 5, + XR_BODY_TRACKING_MESSAGE_USER_CHANGE_BD = 6, + XR_BODY_TRACKING_MESSAGE_TRACKING_POSE_ERROR_BD = 7, + XR_BODY_TRACKING_MESSAGE_MAX_ENUM_BD = 0x7FFFFFFF +} XrBodyTrackingMessageBD; +typedef XrFlags64 XrSpaceAccelerationFlagsBD; + +// Flag bits for XrSpaceAccelerationFlagsBD +static const XrSpaceAccelerationFlagsBD XR_SPACE_ACCELERATION_LINEAR_VALID_BIT_BD = 0x00000001; +static const XrSpaceAccelerationFlagsBD XR_SPACE_ACCELERATION_ANGULAR_VALID_BIT_BD = 0x00000002; + +// XrBodyTrackingPostureDataBD extends XrBodyJointLocationsBD +typedef struct XrBodyTrackingPostureDataBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t postureCount; + XrBodyTrackingPostureBD* postureData; +} XrBodyTrackingPostureDataBD; + +typedef struct XrBodyJointVelocityBD { + XrSpaceVelocityFlags velocityFlags; + XrVector3f linearVelocity; + XrVector3f angularVelocity; +} XrBodyJointVelocityBD; + +// XrBodyJointVelocitiesBD extends XrBodyJointLocationsBD +typedef struct XrBodyJointVelocitiesBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t velocityCount; + XrBodyJointVelocityBD* velocities; +} XrBodyJointVelocitiesBD; + +typedef struct XrBodyJointAccelerationBD { + XrSpaceAccelerationFlagsBD accelerationFlags; + XrVector3f linearAcceleration; + XrVector3f angularAcceleration; +} XrBodyJointAccelerationBD; + +// XrBodyJointAccelerationsBD extends XrBodyJointLocationsBD +typedef struct XrBodyJointAccelerationsBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t accelerationCount; + XrBodyJointAccelerationBD* accelerations; +} XrBodyJointAccelerationsBD; + +typedef struct XrBodyTrackingStateBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBodyTrackingStatusBD status; + XrBodyTrackingMessageBD message; +} XrBodyTrackingStateBD; + +typedef XrResult (XRAPI_PTR *PFN_xrStartBodyTrackingCalibrationAppBD)(XrSession session); +typedef XrResult (XRAPI_PTR *PFN_xrGetBodyTrackingStateBD)(XrSession session, XrBodyTrackingStateBD* state); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrStartBodyTrackingCalibrationAppBD( + XrSession session); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetBodyTrackingStateBD( + XrSession session, + XrBodyTrackingStateBD* state); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_BD_spatial_plane is a preprocessor guard. Do not pass it to API calls. +#define XR_BD_spatial_plane 1 +#define XR_BD_spatial_plane_SPEC_VERSION 1 +#define XR_BD_SPATIAL_PLANE_EXTENSION_NAME "XR_BD_spatial_plane" + +typedef enum XrPlaneOrientationBD { + XR_PLANE_ORIENTATION_HORIZONTAL_UPWARD_BD = 0, + XR_PLANE_ORIENTATION_HORIZONTAL_DOWNWARD_BD = 1, + XR_PLANE_ORIENTATION_VERTICAL_BD = 2, + XR_PLANE_ORIENTATION_ARBITRARY_BD = 3, + XR_PLANE_ORIENTATION_MAX_ENUM_BD = 0x7FFFFFFF +} XrPlaneOrientationBD; +// XrSystemSpatialPlanePropertiesBD extends XrSystemProperties +typedef struct XrSystemSpatialPlanePropertiesBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsSpatialPlane; +} XrSystemSpatialPlanePropertiesBD; + +// XrSpatialEntityComponentDataPlaneOrientationBD extends XrSpatialEntityComponentDataBaseHeaderBD +typedef struct XrSpatialEntityComponentDataPlaneOrientationBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrPlaneOrientationBD orientation; +} XrSpatialEntityComponentDataPlaneOrientationBD; + +// XrSenseDataFilterPlaneOrientationBD extends XrSenseDataQueryInfoBD +typedef struct XrSenseDataFilterPlaneOrientationBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t orientationCount; + XrPlaneOrientationBD* orientations; +} XrSenseDataFilterPlaneOrientationBD; + + + +// XR_BD_spatial_light_estimation is a preprocessor guard. Do not pass it to API calls. +#define XR_BD_spatial_light_estimation 1 +#define XR_BD_spatial_light_estimation_SPEC_VERSION 1 +#define XR_BD_SPATIAL_LIGHT_ESTIMATION_EXTENSION_NAME "XR_BD_spatial_light_estimation" + +typedef enum XrEnvironmentTexturePixelFormatBD { + XR_ENVIRONMENT_TEXTURE_PIXEL_FORMAT_RGB_16FLOAT_BD = 0, + XR_ENVIRONMENT_TEXTURE_PIXEL_FORMAT_RGBA_16FLOAT_BD = 1, + XR_ENVIRONMENT_TEXTURE_PIXEL_FORMAT_MAX_ENUM_BD = 0x7FFFFFFF +} XrEnvironmentTexturePixelFormatBD; + +typedef enum XrEnvironmentTextureResolutionBD { + XR_ENVIRONMENT_TEXTURE_RESOLUTION_8_8_BD = 0, + XR_ENVIRONMENT_TEXTURE_RESOLUTION_16_16_BD = 1, + XR_ENVIRONMENT_TEXTURE_RESOLUTION_32_32_BD = 2, + XR_ENVIRONMENT_TEXTURE_RESOLUTION_64_64_BD = 3, + XR_ENVIRONMENT_TEXTURE_RESOLUTION_128_128_BD = 4, + XR_ENVIRONMENT_TEXTURE_RESOLUTION_MAX_ENUM_BD = 0x7FFFFFFF +} XrEnvironmentTextureResolutionBD; + +typedef enum XrEnvironmentTextureTransferTypeBD { + XR_ENVIRONMENT_TEXTURE_TRANSFER_TYPE_RAW_BD = 0, + XR_ENVIRONMENT_TEXTURE_TRANSFER_TYPE_MAX_ENUM_BD = 0x7FFFFFFF +} XrEnvironmentTextureTransferTypeBD; + +typedef enum XrSphericalHarmonicsKindBD { + XR_SPHERICAL_HARMONICS_KIND_TOTAL_BD = 0, + XR_SPHERICAL_HARMONICS_KIND_MAX_ENUM_BD = 0x7FFFFFFF +} XrSphericalHarmonicsKindBD; +typedef XrFlags64 XrLightEstimationCreateFlagsBD; + +// Flag bits for XrLightEstimationCreateFlagsBD +static const XrLightEstimationCreateFlagsBD XR_LIGHT_ESTIMATION_CREATE_SPHERICAL_HARMONICS_BIT_BD = 0x00000001; +static const XrLightEstimationCreateFlagsBD XR_LIGHT_ESTIMATION_CREATE_ENVIRONMENT_TEXTURE_BIT_BD = 0x00000002; + +// XrSystemLightEstimationPropertiesBD extends XrSystemProperties +typedef struct XrSystemLightEstimationPropertiesBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsLightEstimation; + XrBool32 supportsEnvironmentTexture; + XrBool32 supportsSphericalHarmonics; +} XrSystemLightEstimationPropertiesBD; + +// XrSenseDataProviderCreateInfoLightEstimationBD extends XrSenseDataProviderCreateInfoBD +typedef struct XrSenseDataProviderCreateInfoLightEstimationBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrLightEstimationCreateFlagsBD createFlags; +} XrSenseDataProviderCreateInfoLightEstimationBD; + +// XrEnvironmentTextureCreateConfigInfoBD extends XrSenseDataProviderCreateInfoBD +typedef struct XrEnvironmentTextureCreateConfigInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrEnvironmentTexturePixelFormatBD pixelFormat; + XrEnvironmentTextureResolutionBD resolution; + XrEnvironmentTextureTransferTypeBD transferType; +} XrEnvironmentTextureCreateConfigInfoBD; + +// XrLightEstimationDataEnvironmentTextureRawBD extends XrSpatialEntityComponentDataLightEstimationBD +typedef struct XrLightEstimationDataEnvironmentTextureRawBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrEnvironmentTexturePixelFormatBD pixelFormat; + uint32_t cubemapFaceBufferSize; + uint8_t* rightCubemapFaceBuffer; + uint8_t* leftCubemapFaceBuffer; + uint8_t* topCubemapFaceBuffer; + uint8_t* bottomCubemapFaceBuffer; + uint8_t* frontCubemapFaceBuffer; + uint8_t* backCubemapFaceBuffer; +} XrLightEstimationDataEnvironmentTextureRawBD; + +// XrLightEstimationDataSphericalHarmonicsBD extends XrSpatialEntityComponentDataLightEstimationBD +typedef struct XrLightEstimationDataSphericalHarmonicsBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSphericalHarmonicsKindBD kind; + uint32_t coefficientCapacityInput; + uint32_t coefficientCountOutput; + float* coefficients; +} XrLightEstimationDataSphericalHarmonicsBD; + +// XrSpatialEntityComponentDataLightEstimationBD extends XrSpatialEntityComponentDataBaseHeaderBD +typedef struct XrSpatialEntityComponentDataLightEstimationBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 isValid; +} XrSpatialEntityComponentDataLightEstimationBD; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateEnvironmentTextureResolutionsBD)(XrSession session, uint32_t resolutionCapacityInput, uint32_t* resolutionCountOutput, XrEnvironmentTextureResolutionBD* resolutions); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateEnvironmentTexturePixelFormatsBD)(XrSession session, uint32_t pixelFormatCapacityInput, uint32_t* pixelFormatCountOutput, XrEnvironmentTexturePixelFormatBD* pixelFormats); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateEnvironmentTextureTransferTypesBD)(XrSession session, uint32_t transferTypeCapacityInput, uint32_t* transferTypeCountOutput, XrEnvironmentTextureTransferTypeBD* transferTypes); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateEnvironmentTextureResolutionsBD( + XrSession session, + uint32_t resolutionCapacityInput, + uint32_t* resolutionCountOutput, + XrEnvironmentTextureResolutionBD* resolutions); + +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateEnvironmentTexturePixelFormatsBD( + XrSession session, + uint32_t pixelFormatCapacityInput, + uint32_t* pixelFormatCountOutput, + XrEnvironmentTexturePixelFormatBD* pixelFormats); + +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateEnvironmentTextureTransferTypesBD( + XrSession session, + uint32_t transferTypeCapacityInput, + uint32_t* transferTypeCountOutput, + XrEnvironmentTextureTransferTypeBD* transferTypes); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_BD_ultra_controller_interaction is a preprocessor guard. Do not pass it to API calls. +#define XR_BD_ultra_controller_interaction 1 +#define XR_BD_ultra_controller_interaction_SPEC_VERSION 1 +#define XR_BD_ULTRA_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_BD_ultra_controller_interaction" + + +// XR_BD_spatial_audio_rendering is a preprocessor guard. Do not pass it to API calls. +#define XR_BD_spatial_audio_rendering 1 +XR_DEFINE_HANDLE(XrSpatialAudioRendererBD) +XR_DEFINE_HANDLE(XrSoundFieldBD) +XR_DEFINE_HANDLE(XrSoundObjectBD) +XR_DEFINE_HANDLE(XrSoundObstacleBD) +XR_DEFINE_HANDLE(XrSoundObstacleMaterialBD) +#define XR_BD_spatial_audio_rendering_SPEC_VERSION 1 +#define XR_BD_SPATIAL_AUDIO_RENDERING_EXTENSION_NAME "XR_BD_spatial_audio_rendering" + +typedef enum XrAudioSampleRateBD { + XR_AUDIO_SAMPLE_RATE_192000_HZ_BD = 1, + XR_AUDIO_SAMPLE_RATE_96000_HZ_BD = 2, + XR_AUDIO_SAMPLE_RATE_48000_HZ_BD = 3, + XR_AUDIO_SAMPLE_RATE_44100_HZ_BD = 4, + XR_AUDIO_SAMPLE_RATE_32000_HZ_BD = 5, + XR_AUDIO_SAMPLE_RATE_24000_HZ_BD = 6, + XR_AUDIO_SAMPLE_RATE_22050_HZ_BD = 7, + XR_AUDIO_SAMPLE_RATE_16000_HZ_BD = 8, + XR_AUDIO_SAMPLE_RATE_12000_HZ_BD = 9, + XR_AUDIO_SAMPLE_RATE_11025_HZ_BD = 10, + XR_AUDIO_SAMPLE_RATE_8000_HZ_BD = 11, + XR_AUDIO_SAMPLE_RATE_MAX_ENUM_BD = 0x7FFFFFFF +} XrAudioSampleRateBD; + +typedef enum XrAudioBufferChannelLayoutBD { + XR_AUDIO_BUFFER_CHANNEL_LAYOUT_INTERLEAVED_BD = 0, + XR_AUDIO_BUFFER_CHANNEL_LAYOUT_PLANAR_BD = 1, + XR_AUDIO_BUFFER_CHANNEL_LAYOUT_MAX_ENUM_BD = 0x7FFFFFFF +} XrAudioBufferChannelLayoutBD; + +typedef enum XrSoundObjectDistanceAttenuationTypeBD { + XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_NONE_BD = 0, + XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_INVERSE_SQUARE_BD = 1, + XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_ROLLOFF_BD = 2, + XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_CUSTOMIZED_BD = 100, + XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_MAX_ENUM_BD = 0x7FFFFFFF +} XrSoundObjectDistanceAttenuationTypeBD; + +typedef enum XrSoundFieldChannelMaskSurroundBD { + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_LEFT_BD = 1, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_RIGHT_BD = 2, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_CENTER_BD = 4, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_LOW_FREQUENCY_BD = 8, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_LEFT_BD = 16, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_RIGHT_BD = 32, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SIDE_LEFT_BD = 64, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SIDE_RIGHT_BD = 128, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_LEFT_BD = 256, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_RIGHT_BD = 512, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_BACK_LEFT_BD = 1024, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_BACK_RIGHT_BD = 2048, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_CENTER_BD = 4096, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_SIDE_LEFT_BD = 8192, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_SIDE_RIGHT_BD = 16384, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_STEREO_BD = 3, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_2_1_BD = 11, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_3_0_BD = 7, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_4_0_BD = 4099, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_BACK_SURROUND_BD = 48, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_QUAD_BD = 51, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_3_1_BD = 15, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_0_BD = 55, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_SIDE_SURROUND_BD = 192, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_0_SIDE_BD = 199, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_BD = 63, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_SIDE_BD = 207, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_0_BD = 247, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_1_BD = 255, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_2_BD = 831, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_4_BD = 3903, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_1_2_BD = 24831, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_1_4_BD = 4095, + XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_MAX_ENUM_BD = 0x7FFFFFFF +} XrSoundFieldChannelMaskSurroundBD; + +typedef enum XrSoundFieldChannelMaskAmbixBD { + XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_1ST_ORDER_BD = 1, + XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_2ND_ORDER_BD = 2, + XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_3RD_ORDER_BD = 3, + XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_4TH_ORDER_BD = 4, + XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_5TH_ORDER_BD = 5, + XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_6TH_ORDER_BD = 6, + XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_7TH_ORDER_BD = 7, + XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_MAX_ENUM_BD = 0x7FFFFFFF +} XrSoundFieldChannelMaskAmbixBD; + +typedef enum XrSoundFieldChannelMaskFumaBD { + XR_SOUND_FIELD_CHANNEL_MASK_FUMA_1ST_ORDER_BD = 1, + XR_SOUND_FIELD_CHANNEL_MASK_FUMA_MAX_ENUM_BD = 0x7FFFFFFF +} XrSoundFieldChannelMaskFumaBD; + +typedef enum XrSoundObstacleMaterialTypeBD { + XR_SOUND_OBSTACLE_MATERIAL_TYPE_ACOUSTIC_TILE_BD = 0, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_BRICK_BD = 1, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_BRICK_PAINTED_BD = 2, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_CARPET_BD = 3, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_CARPET_HEAVY_BD = 4, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_CARPET_HEAVY_PADDED_BD = 5, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_CERAMIC_TILE_BD = 6, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_BD = 7, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_ROUGH_BD = 8, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_BLOCK_BD = 9, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_BLOCK_PAINTED_BD = 10, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_CURTAIN_BD = 11, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_FOLIAGE_BD = 12, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_GLASS_BD = 13, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_GLASS_HEAVY_BD = 14, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_GRASS_BD = 15, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_GRAVEL_BD = 16, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_GYPSUM_BOARD_BD = 17, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_PLASTER_ON_BRICK_BD = 18, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_PLASTER_ON_CONCRETE_BLOCK_BD = 19, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_SOIL_BD = 20, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_SOUND_PROOF_BD = 21, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_SNOW_BD = 22, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_STEEL_BD = 23, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_WATER_BD = 24, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_THIN_BD = 25, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_THICK_BD = 26, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_FLOOR_BD = 27, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_ON_CONCRETE_BD = 28, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_CUSTOM_BD = 29, + XR_SOUND_OBSTACLE_MATERIAL_TYPE_MAX_ENUM_BD = 0x7FFFFFFF +} XrSoundObstacleMaterialTypeBD; +typedef XrFlags64 XrSoundObstacleFlagsBD; + +// Flag bits for XrSoundObstacleFlagsBD +static const XrSoundObstacleFlagsBD XR_SOUND_OBSTACLE_ENABLED_BIT_BD = 0x00000001; +static const XrSoundObstacleFlagsBD XR_SOUND_OBSTACLE_POSE_BIT_BD = 0x00000002; +static const XrSoundObstacleFlagsBD XR_SOUND_OBSTACLE_MESH_BIT_BD = 0x00000004; +static const XrSoundObstacleFlagsBD XR_SOUND_OBSTACLE_MATERIALS_BIT_BD = 0x00000008; + +typedef XrFlags64 XrSoundObjectFlagsBD; + +// Flag bits for XrSoundObjectFlagsBD +static const XrSoundObjectFlagsBD XR_SOUND_OBJECT_ENABLED_BIT_BD = 0x00000001; +static const XrSoundObjectFlagsBD XR_SOUND_OBJECT_POSE_BIT_BD = 0x00000002; +static const XrSoundObjectFlagsBD XR_SOUND_OBJECT_DIRECTIVITY_BIT_BD = 0x00000004; +static const XrSoundObjectFlagsBD XR_SOUND_OBJECT_SHAPE_BIT_BD = 0x00000008; +static const XrSoundObjectFlagsBD XR_SOUND_OBJECT_MAIN_VOLUME_BIT_BD = 0x00000010; +static const XrSoundObjectFlagsBD XR_SOUND_OBJECT_REFLECTION_GAIN_BIT_BD = 0x00000020; +static const XrSoundObjectFlagsBD XR_SOUND_OBJECT_ENABLE_DOPPLER_BIT_BD = 0x00000040; +static const XrSoundObjectFlagsBD XR_SOUND_OBJECT_DIRECT_SOUND_ATTENUATION_BIT_BD = 0x00000080; +static const XrSoundObjectFlagsBD XR_SOUND_OBJECT_INDIRECT_SOUND_ATTENUATION_BIT_BD = 0x00000100; + +typedef XrFlags64 XrSoundFieldFlagsBD; + +// Flag bits for XrSoundFieldFlagsBD +static const XrSoundFieldFlagsBD XR_SOUND_FIELD_ENABLED_BIT_BD = 0x00000001; +static const XrSoundFieldFlagsBD XR_SOUND_FIELD_ORIENTATION_BIT_BD = 0x00000002; +static const XrSoundFieldFlagsBD XR_SOUND_FIELD_MAIN_VOLUME_BIT_BD = 0x00000004; +static const XrSoundFieldFlagsBD XR_SOUND_FIELD_LFE_GAIN_BIT_BD = 0x00000008; + +typedef struct XrSpatialAudioRendererCreateInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t framesPerBuffer; + XrAudioSampleRateBD sampleRate; +} XrSpatialAudioRendererCreateInfoBD; + +typedef struct XrAudioBufferBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAudioBufferChannelLayoutBD channelLayout; + uint32_t bufferChannels; + uint32_t bufferLength; + float* buffer; +} XrAudioBufferBD; + +// XrSoundObjectDirectivityCardioidBD extends XrSoundObjectConfigBD +typedef struct XrSoundObjectDirectivityCardioidBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + float alpha; + float order; +} XrSoundObjectDirectivityCardioidBD; + +// XrSoundObjectShapeSphereBD extends XrSoundObjectConfigBD +typedef struct XrSoundObjectShapeSphereBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + float radius; +} XrSoundObjectShapeSphereBD; + +typedef struct XrAttenuationCurvePointBD { + float distance; + float gain; +} XrAttenuationCurvePointBD; + +typedef struct XrSoundObjectDistanceAttenuationCurveBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t curvePointCount; + XrAttenuationCurvePointBD* curvePoints; +} XrSoundObjectDistanceAttenuationCurveBD; + +typedef struct XrSoundObjectDistanceAttenuationBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSoundObjectDistanceAttenuationTypeBD distanceAttenuationType; + float minAttenuationRange; + float maxAttenuationRange; + float referenceDistance; + float rolloffFactor; + XrSoundObjectDistanceAttenuationCurveBD* customDistanceAttenuationCurve; +} XrSoundObjectDistanceAttenuationBD; + +typedef struct XrSoundObjectConfigBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 enabled; + XrPosef pose; + XrSpace baseSpace; + float mainVolume; + float reflectionGain; + XrBool32 enableDoppler; + const XrSoundObjectDistanceAttenuationBD* directSoundAttenuation; + const XrSoundObjectDistanceAttenuationBD* indirectSoundAttenuation; +} XrSoundObjectConfigBD; + +typedef struct XrSoundFieldConfigBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 enabled; + XrQuaternionf orientation; + XrSpace baseSpace; + float mainVolume; + float lfeGain; +} XrSoundFieldConfigBD; + +// XrSoundFieldChannelDefinitionSurroundBD extends XrSoundFieldConfigBD +typedef struct XrSoundFieldChannelDefinitionSurroundBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSoundFieldChannelMaskSurroundBD channelMask; +} XrSoundFieldChannelDefinitionSurroundBD; + +// XrSoundFieldChannelDefinitionAmbixBD extends XrSoundFieldConfigBD +typedef struct XrSoundFieldChannelDefinitionAmbixBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSoundFieldChannelMaskAmbixBD channelMask; +} XrSoundFieldChannelDefinitionAmbixBD; + +// XrSoundFieldChannelDefinitionFumaBD extends XrSoundFieldConfigBD +typedef struct XrSoundFieldChannelDefinitionFumaBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSoundFieldChannelMaskFumaBD channelMask; +} XrSoundFieldChannelDefinitionFumaBD; + +typedef struct XrSoundTriangleMeshBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t vertexCount; + XrVector3f* vertices; + uint32_t indexCount; + uint32_t* indices; +} XrSoundTriangleMeshBD; + +typedef struct XrSoundObstacleConfigBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 enabled; + XrPosef pose; + XrSpace baseSpace; + uint32_t materialCount; + XrSoundObstacleMaterialBD* materials; +} XrSoundObstacleConfigBD; + +typedef struct XrSoundObstacleMaterialConfigBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSoundObstacleMaterialTypeBD materialType; + uint32_t bandCount; + float* bandFrequencies; + float* bandAbsorptions; + float* bandScatterings; + float* bandTransmissions; +} XrSoundObstacleMaterialConfigBD; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSupportedAudioSampleRateBD)(XrSession session, uint32_t sampleRateCapacityInput, uint32_t* sampleRateCountOutput, XrAudioSampleRateBD* sampleRates); +typedef XrResult (XRAPI_PTR *PFN_xrQueryFramesPerBufferRangeBD)(XrSession session, XrAudioSampleRateBD sampleRate, uint32_t* min, uint32_t* max); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAudioRendererBD)(XrSession session, const XrSpatialAudioRendererCreateInfoBD* createInfo, XrSpatialAudioRendererBD* renderer); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialAudioRendererBD)(XrSpatialAudioRendererBD renderer); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSoundObstacleMaterialBD)(XrSpatialAudioRendererBD renderer, const XrSoundObstacleMaterialConfigBD* config, XrSoundObstacleMaterialBD* material); +typedef XrResult (XRAPI_PTR *PFN_xrUpdateSoundObstacleMaterialConfigBD)(XrSoundObstacleMaterialBD material, const XrSoundObstacleMaterialConfigBD* config); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySoundObstacleMaterialBD)(XrSoundObstacleMaterialBD material); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSoundObstacleBD)(XrSpatialAudioRendererBD renderer, const XrSoundObstacleConfigBD* config, const XrSoundTriangleMeshBD* mesh, XrSoundObstacleBD* soundObstacle); +typedef XrResult (XRAPI_PTR *PFN_xrUpdateSoundObstacleConfigBD)(XrSoundObstacleBD soundObstacle, const XrSoundObstacleConfigBD* config, const XrSoundTriangleMeshBD* mesh, XrSoundObstacleFlagsBD flags); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySoundObstacleBD)(XrSoundObstacleBD soundObstacle); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSoundObjectBD)(XrSpatialAudioRendererBD renderer, const XrSoundObjectConfigBD* config, XrSoundObjectBD* soundObject); +typedef XrResult (XRAPI_PTR *PFN_xrUpdateSoundObjectConfigBD)(XrSoundObjectBD soundObject, const XrSoundObjectConfigBD* config, XrSoundObjectFlagsBD flags); +typedef XrResult (XRAPI_PTR *PFN_xrSubmitSoundObjectBufferBD)(XrSoundObjectBD soundObject, const XrAudioBufferBD* buffer); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySoundObjectBD)(XrSoundObjectBD soundObject); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSoundFieldBD)(XrSpatialAudioRendererBD renderer, const XrSoundFieldConfigBD* config, XrSoundFieldBD* soundField); +typedef XrResult (XRAPI_PTR *PFN_xrUpdateSoundFieldConfigBD)(XrSoundFieldBD soundField, const XrSoundFieldConfigBD* config, XrSoundFieldFlagsBD flags); +typedef XrResult (XRAPI_PTR *PFN_xrSubmitSoundFieldBufferBD)(XrSoundFieldBD soundField, const XrAudioBufferBD* buffer); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySoundFieldBD)(XrSoundFieldBD soundField); +typedef XrResult (XRAPI_PTR *PFN_xrWaitAudioPeriodBD)(XrSpatialAudioRendererBD renderer, XrDuration timeout); +typedef XrResult (XRAPI_PTR *PFN_xrEndAudioPeriodBD)(XrSpatialAudioRendererBD renderer); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSupportedAudioSampleRateBD( + XrSession session, + uint32_t sampleRateCapacityInput, + uint32_t* sampleRateCountOutput, + XrAudioSampleRateBD* sampleRates); + +XRAPI_ATTR XrResult XRAPI_CALL xrQueryFramesPerBufferRangeBD( + XrSession session, + XrAudioSampleRateBD sampleRate, + uint32_t* min, + uint32_t* max); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAudioRendererBD( + XrSession session, + const XrSpatialAudioRendererCreateInfoBD* createInfo, + XrSpatialAudioRendererBD* renderer); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialAudioRendererBD( + XrSpatialAudioRendererBD renderer); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSoundObstacleMaterialBD( + XrSpatialAudioRendererBD renderer, + const XrSoundObstacleMaterialConfigBD* config, + XrSoundObstacleMaterialBD* material); + +XRAPI_ATTR XrResult XRAPI_CALL xrUpdateSoundObstacleMaterialConfigBD( + XrSoundObstacleMaterialBD material, + const XrSoundObstacleMaterialConfigBD* config); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySoundObstacleMaterialBD( + XrSoundObstacleMaterialBD material); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSoundObstacleBD( + XrSpatialAudioRendererBD renderer, + const XrSoundObstacleConfigBD* config, + const XrSoundTriangleMeshBD* mesh, + XrSoundObstacleBD* soundObstacle); + +XRAPI_ATTR XrResult XRAPI_CALL xrUpdateSoundObstacleConfigBD( + XrSoundObstacleBD soundObstacle, + const XrSoundObstacleConfigBD* config, + const XrSoundTriangleMeshBD* mesh, + XrSoundObstacleFlagsBD flags); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySoundObstacleBD( + XrSoundObstacleBD soundObstacle); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSoundObjectBD( + XrSpatialAudioRendererBD renderer, + const XrSoundObjectConfigBD* config, + XrSoundObjectBD* soundObject); + +XRAPI_ATTR XrResult XRAPI_CALL xrUpdateSoundObjectConfigBD( + XrSoundObjectBD soundObject, + const XrSoundObjectConfigBD* config, + XrSoundObjectFlagsBD flags); + +XRAPI_ATTR XrResult XRAPI_CALL xrSubmitSoundObjectBufferBD( + XrSoundObjectBD soundObject, + const XrAudioBufferBD* buffer); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySoundObjectBD( + XrSoundObjectBD soundObject); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSoundFieldBD( + XrSpatialAudioRendererBD renderer, + const XrSoundFieldConfigBD* config, + XrSoundFieldBD* soundField); + +XRAPI_ATTR XrResult XRAPI_CALL xrUpdateSoundFieldConfigBD( + XrSoundFieldBD soundField, + const XrSoundFieldConfigBD* config, + XrSoundFieldFlagsBD flags); + +XRAPI_ATTR XrResult XRAPI_CALL xrSubmitSoundFieldBufferBD( + XrSoundFieldBD soundField, + const XrAudioBufferBD* buffer); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySoundFieldBD( + XrSoundFieldBD soundField); + +XRAPI_ATTR XrResult XRAPI_CALL xrWaitAudioPeriodBD( + XrSpatialAudioRendererBD renderer, + XrDuration timeout); + +XRAPI_ATTR XrResult XRAPI_CALL xrEndAudioPeriodBD( + XrSpatialAudioRendererBD renderer); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_EXT_local_floor is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_local_floor 1 +#define XR_EXT_local_floor_SPEC_VERSION 1 +#define XR_EXT_LOCAL_FLOOR_EXTENSION_NAME "XR_EXT_local_floor" + + +// XR_EXT_hand_tracking_data_source is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_hand_tracking_data_source 1 +#define XR_EXT_hand_tracking_data_source_SPEC_VERSION 1 +#define XR_EXT_HAND_TRACKING_DATA_SOURCE_EXTENSION_NAME "XR_EXT_hand_tracking_data_source" + +typedef enum XrHandTrackingDataSourceEXT { + XR_HAND_TRACKING_DATA_SOURCE_UNOBSTRUCTED_EXT = 1, + XR_HAND_TRACKING_DATA_SOURCE_CONTROLLER_EXT = 2, + XR_HAND_TRACKING_DATA_SOURCE_UNOBSTRUCTED_WIDE_MOTION_META = 1000695000, + XR_HAND_TRACKING_DATA_SOURCE_MAX_ENUM_EXT = 0x7FFFFFFF +} XrHandTrackingDataSourceEXT; +// XrHandTrackingDataSourceInfoEXT extends XrHandTrackerCreateInfoEXT +typedef struct XrHandTrackingDataSourceInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t requestedDataSourceCount; + XrHandTrackingDataSourceEXT* requestedDataSources; +} XrHandTrackingDataSourceInfoEXT; + +// XrHandTrackingDataSourceStateEXT extends XrHandJointLocationsEXT +typedef struct XrHandTrackingDataSourceStateEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 isActive; + XrHandTrackingDataSourceEXT dataSource; +} XrHandTrackingDataSourceStateEXT; + + + +// XR_EXT_plane_detection is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_plane_detection 1 +XR_DEFINE_HANDLE(XrPlaneDetectorEXT) +#define XR_EXT_plane_detection_SPEC_VERSION 2 +#define XR_EXT_PLANE_DETECTION_EXTENSION_NAME "XR_EXT_plane_detection" + +typedef enum XrPlaneDetectorOrientationEXT { + XR_PLANE_DETECTOR_ORIENTATION_HORIZONTAL_UPWARD_EXT = 0, + XR_PLANE_DETECTOR_ORIENTATION_HORIZONTAL_DOWNWARD_EXT = 1, + XR_PLANE_DETECTOR_ORIENTATION_VERTICAL_EXT = 2, + XR_PLANE_DETECTOR_ORIENTATION_ARBITRARY_EXT = 3, + XR_PLANE_DETECTOR_ORIENTATION_MAX_ENUM_EXT = 0x7FFFFFFF +} XrPlaneDetectorOrientationEXT; + +typedef enum XrPlaneDetectorSemanticTypeEXT { + XR_PLANE_DETECTOR_SEMANTIC_TYPE_UNDEFINED_EXT = 0, + XR_PLANE_DETECTOR_SEMANTIC_TYPE_CEILING_EXT = 1, + XR_PLANE_DETECTOR_SEMANTIC_TYPE_FLOOR_EXT = 2, + XR_PLANE_DETECTOR_SEMANTIC_TYPE_WALL_EXT = 3, + XR_PLANE_DETECTOR_SEMANTIC_TYPE_PLATFORM_EXT = 4, + XR_PLANE_DETECTOR_SEMANTIC_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} XrPlaneDetectorSemanticTypeEXT; + +typedef enum XrPlaneDetectionStateEXT { + XR_PLANE_DETECTION_STATE_NONE_EXT = 0, + XR_PLANE_DETECTION_STATE_PENDING_EXT = 1, + XR_PLANE_DETECTION_STATE_DONE_EXT = 2, + XR_PLANE_DETECTION_STATE_ERROR_EXT = 3, + XR_PLANE_DETECTION_STATE_FATAL_EXT = 4, + XR_PLANE_DETECTION_STATE_MAX_ENUM_EXT = 0x7FFFFFFF +} XrPlaneDetectionStateEXT; +typedef XrFlags64 XrPlaneDetectionCapabilityFlagsEXT; + +// Flag bits for XrPlaneDetectionCapabilityFlagsEXT +static const XrPlaneDetectionCapabilityFlagsEXT XR_PLANE_DETECTION_CAPABILITY_PLANE_DETECTION_BIT_EXT = 0x00000001; +static const XrPlaneDetectionCapabilityFlagsEXT XR_PLANE_DETECTION_CAPABILITY_PLANE_HOLES_BIT_EXT = 0x00000002; +static const XrPlaneDetectionCapabilityFlagsEXT XR_PLANE_DETECTION_CAPABILITY_SEMANTIC_CEILING_BIT_EXT = 0x00000004; +static const XrPlaneDetectionCapabilityFlagsEXT XR_PLANE_DETECTION_CAPABILITY_SEMANTIC_FLOOR_BIT_EXT = 0x00000008; +static const XrPlaneDetectionCapabilityFlagsEXT XR_PLANE_DETECTION_CAPABILITY_SEMANTIC_WALL_BIT_EXT = 0x00000010; +static const XrPlaneDetectionCapabilityFlagsEXT XR_PLANE_DETECTION_CAPABILITY_SEMANTIC_PLATFORM_BIT_EXT = 0x00000020; +static const XrPlaneDetectionCapabilityFlagsEXT XR_PLANE_DETECTION_CAPABILITY_ORIENTATION_BIT_EXT = 0x00000040; + +typedef XrFlags64 XrPlaneDetectorFlagsEXT; + +// Flag bits for XrPlaneDetectorFlagsEXT +static const XrPlaneDetectorFlagsEXT XR_PLANE_DETECTOR_ENABLE_CONTOUR_BIT_EXT = 0x00000001; + +// XrSystemPlaneDetectionPropertiesEXT extends XrSystemProperties +typedef struct XrSystemPlaneDetectionPropertiesEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrPlaneDetectionCapabilityFlagsEXT supportedFeatures; +} XrSystemPlaneDetectionPropertiesEXT; + +typedef struct XrPlaneDetectorCreateInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrPlaneDetectorFlagsEXT flags; +} XrPlaneDetectorCreateInfoEXT; + +typedef XrExtent3Df XrExtent3DfEXT; + +typedef struct XrPlaneDetectorBeginInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace baseSpace; + XrTime time; + uint32_t orientationCount; + const XrPlaneDetectorOrientationEXT* orientations; + uint32_t semanticTypeCount; + const XrPlaneDetectorSemanticTypeEXT* semanticTypes; + uint32_t maxPlanes; + float minArea; + XrPosef boundingBoxPose; + XrExtent3DfEXT boundingBoxExtent; +} XrPlaneDetectorBeginInfoEXT; + +typedef struct XrPlaneDetectorGetInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace baseSpace; + XrTime time; +} XrPlaneDetectorGetInfoEXT; + +typedef struct XrPlaneDetectorLocationEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint64_t planeId; + XrSpaceLocationFlags locationFlags; + XrPosef pose; + XrExtent2Df extents; + XrPlaneDetectorOrientationEXT orientation; + XrPlaneDetectorSemanticTypeEXT semanticType; + uint32_t polygonBufferCount; +} XrPlaneDetectorLocationEXT; + +typedef struct XrPlaneDetectorLocationsEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t planeLocationCapacityInput; + uint32_t planeLocationCountOutput; + XrPlaneDetectorLocationEXT* planeLocations; +} XrPlaneDetectorLocationsEXT; + +typedef struct XrPlaneDetectorPolygonBufferEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t vertexCapacityInput; + uint32_t vertexCountOutput; + XrVector2f* vertices; +} XrPlaneDetectorPolygonBufferEXT; + +typedef XrResult (XRAPI_PTR *PFN_xrCreatePlaneDetectorEXT)(XrSession session, const XrPlaneDetectorCreateInfoEXT* createInfo, XrPlaneDetectorEXT* planeDetector); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyPlaneDetectorEXT)(XrPlaneDetectorEXT planeDetector); +typedef XrResult (XRAPI_PTR *PFN_xrBeginPlaneDetectionEXT)(XrPlaneDetectorEXT planeDetector, const XrPlaneDetectorBeginInfoEXT* beginInfo); +typedef XrResult (XRAPI_PTR *PFN_xrGetPlaneDetectionStateEXT)(XrPlaneDetectorEXT planeDetector, XrPlaneDetectionStateEXT* state); +typedef XrResult (XRAPI_PTR *PFN_xrGetPlaneDetectionsEXT)(XrPlaneDetectorEXT planeDetector, const XrPlaneDetectorGetInfoEXT* info, XrPlaneDetectorLocationsEXT* locations); +typedef XrResult (XRAPI_PTR *PFN_xrGetPlanePolygonBufferEXT)(XrPlaneDetectorEXT planeDetector, uint64_t planeId, uint32_t polygonBufferIndex, XrPlaneDetectorPolygonBufferEXT* polygonBuffer); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreatePlaneDetectorEXT( + XrSession session, + const XrPlaneDetectorCreateInfoEXT* createInfo, + XrPlaneDetectorEXT* planeDetector); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyPlaneDetectorEXT( + XrPlaneDetectorEXT planeDetector); + +XRAPI_ATTR XrResult XRAPI_CALL xrBeginPlaneDetectionEXT( + XrPlaneDetectorEXT planeDetector, + const XrPlaneDetectorBeginInfoEXT* beginInfo); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetPlaneDetectionStateEXT( + XrPlaneDetectorEXT planeDetector, + XrPlaneDetectionStateEXT* state); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetPlaneDetectionsEXT( + XrPlaneDetectorEXT planeDetector, + const XrPlaneDetectorGetInfoEXT* info, + XrPlaneDetectorLocationsEXT* locations); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetPlanePolygonBufferEXT( + XrPlaneDetectorEXT planeDetector, + uint64_t planeId, + uint32_t polygonBufferIndex, + XrPlaneDetectorPolygonBufferEXT* polygonBuffer); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_OPPO_controller_interaction is a preprocessor guard. Do not pass it to API calls. +#define XR_OPPO_controller_interaction 1 +#define XR_OPPO_controller_interaction_SPEC_VERSION 1 +#define XR_OPPO_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_OPPO_controller_interaction" + + +// XR_ANDROID_trackables is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_trackables 1 + +#define XR_NULL_TRACKABLE_ANDROID 0 + +XR_DEFINE_ATOM(XrTrackableANDROID) +XR_DEFINE_HANDLE(XrTrackableTrackerANDROID) +#define XR_ANDROID_trackables_SPEC_VERSION 2 +#define XR_ANDROID_TRACKABLES_EXTENSION_NAME "XR_ANDROID_trackables" + +typedef enum XrTrackingStateANDROID { + XR_TRACKING_STATE_PAUSED_ANDROID = 0, + XR_TRACKING_STATE_STOPPED_ANDROID = 1, + XR_TRACKING_STATE_TRACKING_ANDROID = 2, + XR_TRACKING_STATE_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrTrackingStateANDROID; + +typedef enum XrTrackableTypeANDROID { + XR_TRACKABLE_TYPE_NOT_VALID_ANDROID = 0, + XR_TRACKABLE_TYPE_PLANE_ANDROID = 1, + XR_TRACKABLE_TYPE_DEPTH_ANDROID = 1000463000, + XR_TRACKABLE_TYPE_OBJECT_ANDROID = 1000466000, + XR_TRACKABLE_TYPE_MARKER_ANDROID = 1000707000, + XR_TRACKABLE_TYPE_QR_CODE_ANDROID = 1000708000, + XR_TRACKABLE_TYPE_IMAGE_ANDROID = 1000709000, + XR_TRACKABLE_TYPE_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrTrackableTypeANDROID; + +typedef enum XrPlaneTypeANDROID { + XR_PLANE_TYPE_HORIZONTAL_DOWNWARD_FACING_ANDROID = 0, + XR_PLANE_TYPE_HORIZONTAL_UPWARD_FACING_ANDROID = 1, + XR_PLANE_TYPE_VERTICAL_ANDROID = 2, + XR_PLANE_TYPE_ARBITRARY_ANDROID = 3, + XR_PLANE_TYPE_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrPlaneTypeANDROID; + +typedef enum XrPlaneLabelANDROID { + XR_PLANE_LABEL_UNKNOWN_ANDROID = 0, + XR_PLANE_LABEL_WALL_ANDROID = 1, + XR_PLANE_LABEL_FLOOR_ANDROID = 2, + XR_PLANE_LABEL_CEILING_ANDROID = 3, + XR_PLANE_LABEL_TABLE_ANDROID = 4, + XR_PLANE_LABEL_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrPlaneLabelANDROID; +typedef struct XrTrackableTrackerCreateInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrTrackableTypeANDROID trackableType; +} XrTrackableTrackerCreateInfoANDROID; + +typedef struct XrTrackableGetInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrTrackableANDROID trackable; + XrSpace baseSpace; + XrTime time; +} XrTrackableGetInfoANDROID; + +typedef struct XrTrackablePlaneANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrTrackingStateANDROID trackingState; + XrPosef centerPose; + XrExtent2Df extents; + XrPlaneTypeANDROID planeType; + XrPlaneLabelANDROID planeLabel; + XrTrackableANDROID subsumedByPlane; + XrTime lastUpdatedTime; + uint32_t vertexCapacityInput; + uint32_t* vertexCountOutput; + XrVector2f* vertices; +} XrTrackablePlaneANDROID; + +typedef struct XrAnchorSpaceCreateInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace space; + XrTime time; + XrPosef pose; + XrTrackableANDROID trackable; +} XrAnchorSpaceCreateInfoANDROID; + +// XrSystemTrackablesPropertiesANDROID extends XrSystemProperties +typedef struct XrSystemTrackablesPropertiesANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 supportsAnchor; + uint32_t maxAnchors; +} XrSystemTrackablesPropertiesANDROID; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSupportedTrackableTypesANDROID)(XrInstance instance, XrSystemId systemId, uint32_t trackableTypeCapacityInput, uint32_t* trackableTypeCountOutput, XrTrackableTypeANDROID* trackableTypes); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSupportedAnchorTrackableTypesANDROID)(XrInstance instance, XrSystemId systemId, uint32_t trackableTypeCapacityInput, uint32_t* trackableTypeCountOutput, XrTrackableTypeANDROID* trackableTypes); +typedef XrResult (XRAPI_PTR *PFN_xrCreateTrackableTrackerANDROID)(XrSession session, const XrTrackableTrackerCreateInfoANDROID* createInfo, XrTrackableTrackerANDROID* trackableTracker); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyTrackableTrackerANDROID)(XrTrackableTrackerANDROID trackableTracker); +typedef XrResult (XRAPI_PTR *PFN_xrGetAllTrackablesANDROID)(XrTrackableTrackerANDROID trackableTracker, uint32_t trackableCapacityInput, uint32_t* trackableCountOutput, XrTrackableANDROID* trackables); +typedef XrResult (XRAPI_PTR *PFN_xrGetTrackablePlaneANDROID)(XrTrackableTrackerANDROID trackableTracker, const XrTrackableGetInfoANDROID* getInfo, XrTrackablePlaneANDROID* planeOutput); +typedef XrResult (XRAPI_PTR *PFN_xrCreateAnchorSpaceANDROID)(XrSession session, const XrAnchorSpaceCreateInfoANDROID* createInfo, XrSpace* anchorOutput); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSupportedTrackableTypesANDROID( + XrInstance instance, + XrSystemId systemId, + uint32_t trackableTypeCapacityInput, + uint32_t* trackableTypeCountOutput, + XrTrackableTypeANDROID* trackableTypes); + +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSupportedAnchorTrackableTypesANDROID( + XrInstance instance, + XrSystemId systemId, + uint32_t trackableTypeCapacityInput, + uint32_t* trackableTypeCountOutput, + XrTrackableTypeANDROID* trackableTypes); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateTrackableTrackerANDROID( + XrSession session, + const XrTrackableTrackerCreateInfoANDROID* createInfo, + XrTrackableTrackerANDROID* trackableTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyTrackableTrackerANDROID( + XrTrackableTrackerANDROID trackableTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetAllTrackablesANDROID( + XrTrackableTrackerANDROID trackableTracker, + uint32_t trackableCapacityInput, + uint32_t* trackableCountOutput, + XrTrackableANDROID* trackables); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetTrackablePlaneANDROID( + XrTrackableTrackerANDROID trackableTracker, + const XrTrackableGetInfoANDROID* getInfo, + XrTrackablePlaneANDROID* planeOutput); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateAnchorSpaceANDROID( + XrSession session, + const XrAnchorSpaceCreateInfoANDROID* createInfo, + XrSpace* anchorOutput); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ANDROID_eye_tracking is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_eye_tracking 1 +XR_DEFINE_HANDLE(XrEyeTrackerANDROID) +#define XR_EYE_MAX_ANDROID 2 +#define XR_ANDROID_eye_tracking_SPEC_VERSION 1 +#define XR_ANDROID_EYE_TRACKING_EXTENSION_NAME "XR_ANDROID_eye_tracking" + +typedef enum XrEyeIndexANDROID { + XR_EYE_INDEX_LEFT_ANDROID = 0, + XR_EYE_INDEX_RIGHT_ANDROID = 1, + XR_EYE_INDEX_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrEyeIndexANDROID; + +typedef enum XrEyeStateANDROID { + XR_EYE_STATE_INVALID_ANDROID = 0, + XR_EYE_STATE_GAZING_ANDROID = 1, + XR_EYE_STATE_SHUT_ANDROID = 2, + XR_EYE_STATE_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrEyeStateANDROID; + +typedef enum XrEyeTrackingModeANDROID { + XR_EYE_TRACKING_MODE_NOT_TRACKING_ANDROID = 0, + XR_EYE_TRACKING_MODE_RIGHT_ANDROID = 1, + XR_EYE_TRACKING_MODE_LEFT_ANDROID = 2, + XR_EYE_TRACKING_MODE_BOTH_ANDROID = 3, + XR_EYE_TRACKING_MODE_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrEyeTrackingModeANDROID; +// XrSystemEyeTrackingPropertiesANDROID extends XrSystemProperties +typedef struct XrSystemEyeTrackingPropertiesANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsEyeTracking; +} XrSystemEyeTrackingPropertiesANDROID; + +typedef struct XrEyeANDROID { + XrEyeStateANDROID eyeState; + XrPosef eyePose; +} XrEyeANDROID; + +typedef struct XrEyesANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrEyeANDROID eyes[XR_EYE_MAX_ANDROID]; + XrEyeTrackingModeANDROID mode; +} XrEyesANDROID; + +typedef struct XrEyesGetInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrTime time; + XrSpace baseSpace; +} XrEyesGetInfoANDROID; + +typedef struct XrEyeTrackerCreateInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrEyeTrackerCreateInfoANDROID; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateEyeTrackerANDROID)(XrSession session, const XrEyeTrackerCreateInfoANDROID* createInfo, XrEyeTrackerANDROID* eyeTracker); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyEyeTrackerANDROID)(XrEyeTrackerANDROID eyeTracker); +typedef XrResult (XRAPI_PTR *PFN_xrGetFineTrackingEyesInfoANDROID)(XrEyeTrackerANDROID eyeTracker, const XrEyesGetInfoANDROID* getInfo, XrEyesANDROID* eyesOutput); +typedef XrResult (XRAPI_PTR *PFN_xrGetCoarseTrackingEyesInfoANDROID)(XrEyeTrackerANDROID eyeTracker, const XrEyesGetInfoANDROID* getInfo, XrEyesANDROID* eyesOutput); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateEyeTrackerANDROID( + XrSession session, + const XrEyeTrackerCreateInfoANDROID* createInfo, + XrEyeTrackerANDROID* eyeTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyEyeTrackerANDROID( + XrEyeTrackerANDROID eyeTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetFineTrackingEyesInfoANDROID( + XrEyeTrackerANDROID eyeTracker, + const XrEyesGetInfoANDROID* getInfo, + XrEyesANDROID* eyesOutput); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetCoarseTrackingEyesInfoANDROID( + XrEyeTrackerANDROID eyeTracker, + const XrEyesGetInfoANDROID* getInfo, + XrEyesANDROID* eyesOutput); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ANDROID_device_anchor_persistence is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_device_anchor_persistence 1 +XR_DEFINE_HANDLE(XrDeviceAnchorPersistenceANDROID) +#define XR_ANDROID_device_anchor_persistence_SPEC_VERSION 1 +#define XR_ANDROID_DEVICE_ANCHOR_PERSISTENCE_EXTENSION_NAME "XR_ANDROID_device_anchor_persistence" + +typedef enum XrAnchorPersistStateANDROID { + XR_ANCHOR_PERSIST_STATE_PERSIST_NOT_REQUESTED_ANDROID = 0, + XR_ANCHOR_PERSIST_STATE_PERSIST_PENDING_ANDROID = 1, + XR_ANCHOR_PERSIST_STATE_PERSISTED_ANDROID = 2, + XR_ANCHOR_PERSIST_STATE_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrAnchorPersistStateANDROID; +typedef struct XrDeviceAnchorPersistenceCreateInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrDeviceAnchorPersistenceCreateInfoANDROID; + +typedef struct XrPersistedAnchorSpaceCreateInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrUuidEXT anchorId; +} XrPersistedAnchorSpaceCreateInfoANDROID; + +typedef struct XrPersistedAnchorSpaceInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace anchor; +} XrPersistedAnchorSpaceInfoANDROID; + +// XrSystemDeviceAnchorPersistencePropertiesANDROID extends XrSystemProperties +typedef struct XrSystemDeviceAnchorPersistencePropertiesANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsAnchorPersistence; +} XrSystemDeviceAnchorPersistencePropertiesANDROID; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSupportedPersistenceAnchorTypesANDROID)(XrInstance instance, XrSystemId systemId, uint32_t trackableTypeCapacityInput, uint32_t* trackableTypeCountOutput, XrTrackableTypeANDROID* trackableTypes); +typedef XrResult (XRAPI_PTR *PFN_xrCreateDeviceAnchorPersistenceANDROID)(XrSession session, const XrDeviceAnchorPersistenceCreateInfoANDROID* createInfo, XrDeviceAnchorPersistenceANDROID* outHandle); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyDeviceAnchorPersistenceANDROID)(XrDeviceAnchorPersistenceANDROID handle); +typedef XrResult (XRAPI_PTR *PFN_xrPersistAnchorANDROID)(XrDeviceAnchorPersistenceANDROID handle, const XrPersistedAnchorSpaceInfoANDROID* persistedInfo, XrUuidEXT* anchorIdOutput); +typedef XrResult (XRAPI_PTR *PFN_xrGetAnchorPersistStateANDROID)(XrDeviceAnchorPersistenceANDROID handle, const XrUuidEXT* anchorId, XrAnchorPersistStateANDROID* persistState); +typedef XrResult (XRAPI_PTR *PFN_xrCreatePersistedAnchorSpaceANDROID)(XrDeviceAnchorPersistenceANDROID handle, const XrPersistedAnchorSpaceCreateInfoANDROID* createInfo, XrSpace* anchorOutput); +typedef XrResult (XRAPI_PTR *PFN_xrEnumeratePersistedAnchorsANDROID)(XrDeviceAnchorPersistenceANDROID handle, uint32_t anchorIdCapacityInput, uint32_t* anchorIdCountOutput, XrUuidEXT* anchorIds); +typedef XrResult (XRAPI_PTR *PFN_xrUnpersistAnchorANDROID)(XrDeviceAnchorPersistenceANDROID handle, const XrUuidEXT* anchorId); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSupportedPersistenceAnchorTypesANDROID( + XrInstance instance, + XrSystemId systemId, + uint32_t trackableTypeCapacityInput, + uint32_t* trackableTypeCountOutput, + XrTrackableTypeANDROID* trackableTypes); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateDeviceAnchorPersistenceANDROID( + XrSession session, + const XrDeviceAnchorPersistenceCreateInfoANDROID* createInfo, + XrDeviceAnchorPersistenceANDROID* outHandle); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyDeviceAnchorPersistenceANDROID( + XrDeviceAnchorPersistenceANDROID handle); + +XRAPI_ATTR XrResult XRAPI_CALL xrPersistAnchorANDROID( + XrDeviceAnchorPersistenceANDROID handle, + const XrPersistedAnchorSpaceInfoANDROID* persistedInfo, + XrUuidEXT* anchorIdOutput); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetAnchorPersistStateANDROID( + XrDeviceAnchorPersistenceANDROID handle, + const XrUuidEXT* anchorId, + XrAnchorPersistStateANDROID* persistState); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreatePersistedAnchorSpaceANDROID( + XrDeviceAnchorPersistenceANDROID handle, + const XrPersistedAnchorSpaceCreateInfoANDROID* createInfo, + XrSpace* anchorOutput); + +XRAPI_ATTR XrResult XRAPI_CALL xrEnumeratePersistedAnchorsANDROID( + XrDeviceAnchorPersistenceANDROID handle, + uint32_t anchorIdCapacityInput, + uint32_t* anchorIdCountOutput, + XrUuidEXT* anchorIds); + +XRAPI_ATTR XrResult XRAPI_CALL xrUnpersistAnchorANDROID( + XrDeviceAnchorPersistenceANDROID handle, + const XrUuidEXT* anchorId); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ANDROID_face_tracking is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_face_tracking 1 +XR_DEFINE_HANDLE(XrFaceTrackerANDROID) +#define XR_ANDROID_face_tracking_SPEC_VERSION 1 +#define XR_ANDROID_FACE_TRACKING_EXTENSION_NAME "XR_ANDROID_face_tracking" +#define XR_FACE_PARAMETER_COUNT_ANDROID 68 +#define XR_FACE_REGION_CONFIDENCE_COUNT_ANDROID 3 + +typedef enum XrFaceParameterIndicesANDROID { + XR_FACE_PARAMETER_INDICES_BROW_LOWERER_L_ANDROID = 0, + XR_FACE_PARAMETER_INDICES_BROW_LOWERER_R_ANDROID = 1, + XR_FACE_PARAMETER_INDICES_CHEEK_PUFF_L_ANDROID = 2, + XR_FACE_PARAMETER_INDICES_CHEEK_PUFF_R_ANDROID = 3, + XR_FACE_PARAMETER_INDICES_CHEEK_RAISER_L_ANDROID = 4, + XR_FACE_PARAMETER_INDICES_CHEEK_RAISER_R_ANDROID = 5, + XR_FACE_PARAMETER_INDICES_CHEEK_SUCK_L_ANDROID = 6, + XR_FACE_PARAMETER_INDICES_CHEEK_SUCK_R_ANDROID = 7, + XR_FACE_PARAMETER_INDICES_CHIN_RAISER_B_ANDROID = 8, + XR_FACE_PARAMETER_INDICES_CHIN_RAISER_T_ANDROID = 9, + XR_FACE_PARAMETER_INDICES_DIMPLER_L_ANDROID = 10, + XR_FACE_PARAMETER_INDICES_DIMPLER_R_ANDROID = 11, + XR_FACE_PARAMETER_INDICES_EYES_CLOSED_L_ANDROID = 12, + XR_FACE_PARAMETER_INDICES_EYES_CLOSED_R_ANDROID = 13, + XR_FACE_PARAMETER_INDICES_EYES_LOOK_DOWN_L_ANDROID = 14, + XR_FACE_PARAMETER_INDICES_EYES_LOOK_DOWN_R_ANDROID = 15, + XR_FACE_PARAMETER_INDICES_EYES_LOOK_LEFT_L_ANDROID = 16, + XR_FACE_PARAMETER_INDICES_EYES_LOOK_LEFT_R_ANDROID = 17, + XR_FACE_PARAMETER_INDICES_EYES_LOOK_RIGHT_L_ANDROID = 18, + XR_FACE_PARAMETER_INDICES_EYES_LOOK_RIGHT_R_ANDROID = 19, + XR_FACE_PARAMETER_INDICES_EYES_LOOK_UP_L_ANDROID = 20, + XR_FACE_PARAMETER_INDICES_EYES_LOOK_UP_R_ANDROID = 21, + XR_FACE_PARAMETER_INDICES_INNER_BROW_RAISER_L_ANDROID = 22, + XR_FACE_PARAMETER_INDICES_INNER_BROW_RAISER_R_ANDROID = 23, + XR_FACE_PARAMETER_INDICES_JAW_DROP_ANDROID = 24, + XR_FACE_PARAMETER_INDICES_JAW_SIDEWAYS_LEFT_ANDROID = 25, + XR_FACE_PARAMETER_INDICES_JAW_SIDEWAYS_RIGHT_ANDROID = 26, + XR_FACE_PARAMETER_INDICES_JAW_THRUST_ANDROID = 27, + XR_FACE_PARAMETER_INDICES_LID_TIGHTENER_L_ANDROID = 28, + XR_FACE_PARAMETER_INDICES_LID_TIGHTENER_R_ANDROID = 29, + XR_FACE_PARAMETER_INDICES_LIP_CORNER_DEPRESSOR_L_ANDROID = 30, + XR_FACE_PARAMETER_INDICES_LIP_CORNER_DEPRESSOR_R_ANDROID = 31, + XR_FACE_PARAMETER_INDICES_LIP_CORNER_PULLER_L_ANDROID = 32, + XR_FACE_PARAMETER_INDICES_LIP_CORNER_PULLER_R_ANDROID = 33, + XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_LB_ANDROID = 34, + XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_LT_ANDROID = 35, + XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_RB_ANDROID = 36, + XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_RT_ANDROID = 37, + XR_FACE_PARAMETER_INDICES_LIP_PRESSOR_L_ANDROID = 38, + XR_FACE_PARAMETER_INDICES_LIP_PRESSOR_R_ANDROID = 39, + XR_FACE_PARAMETER_INDICES_LIP_PUCKER_L_ANDROID = 40, + XR_FACE_PARAMETER_INDICES_LIP_PUCKER_R_ANDROID = 41, + XR_FACE_PARAMETER_INDICES_LIP_STRETCHER_L_ANDROID = 42, + XR_FACE_PARAMETER_INDICES_LIP_STRETCHER_R_ANDROID = 43, + XR_FACE_PARAMETER_INDICES_LIP_SUCK_LB_ANDROID = 44, + XR_FACE_PARAMETER_INDICES_LIP_SUCK_LT_ANDROID = 45, + XR_FACE_PARAMETER_INDICES_LIP_SUCK_RB_ANDROID = 46, + XR_FACE_PARAMETER_INDICES_LIP_SUCK_RT_ANDROID = 47, + XR_FACE_PARAMETER_INDICES_LIP_TIGHTENER_L_ANDROID = 48, + XR_FACE_PARAMETER_INDICES_LIP_TIGHTENER_R_ANDROID = 49, + XR_FACE_PARAMETER_INDICES_LIPS_TOWARD_ANDROID = 50, + XR_FACE_PARAMETER_INDICES_LOWER_LIP_DEPRESSOR_L_ANDROID = 51, + XR_FACE_PARAMETER_INDICES_LOWER_LIP_DEPRESSOR_R_ANDROID = 52, + XR_FACE_PARAMETER_INDICES_MOUTH_LEFT_ANDROID = 53, + XR_FACE_PARAMETER_INDICES_MOUTH_RIGHT_ANDROID = 54, + XR_FACE_PARAMETER_INDICES_NOSE_WRINKLER_L_ANDROID = 55, + XR_FACE_PARAMETER_INDICES_NOSE_WRINKLER_R_ANDROID = 56, + XR_FACE_PARAMETER_INDICES_OUTER_BROW_RAISER_L_ANDROID = 57, + XR_FACE_PARAMETER_INDICES_OUTER_BROW_RAISER_R_ANDROID = 58, + XR_FACE_PARAMETER_INDICES_UPPER_LID_RAISER_L_ANDROID = 59, + XR_FACE_PARAMETER_INDICES_UPPER_LID_RAISER_R_ANDROID = 60, + XR_FACE_PARAMETER_INDICES_UPPER_LIP_RAISER_L_ANDROID = 61, + XR_FACE_PARAMETER_INDICES_UPPER_LIP_RAISER_R_ANDROID = 62, + XR_FACE_PARAMETER_INDICES_TONGUE_OUT_ANDROID = 63, + XR_FACE_PARAMETER_INDICES_TONGUE_LEFT_ANDROID = 64, + XR_FACE_PARAMETER_INDICES_TONGUE_RIGHT_ANDROID = 65, + XR_FACE_PARAMETER_INDICES_TONGUE_UP_ANDROID = 66, + XR_FACE_PARAMETER_INDICES_TONGUE_DOWN_ANDROID = 67, + XR_FACE_PARAMETER_INDICES_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrFaceParameterIndicesANDROID; + +typedef enum XrFaceTrackingStateANDROID { + XR_FACE_TRACKING_STATE_PAUSED_ANDROID = 0, + XR_FACE_TRACKING_STATE_STOPPED_ANDROID = 1, + XR_FACE_TRACKING_STATE_TRACKING_ANDROID = 2, + XR_FACE_TRACKING_STATE_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrFaceTrackingStateANDROID; + +typedef enum XrFaceConfidenceRegionsANDROID { + XR_FACE_CONFIDENCE_REGIONS_LOWER_ANDROID = 0, + XR_FACE_CONFIDENCE_REGIONS_LEFT_UPPER_ANDROID = 1, + XR_FACE_CONFIDENCE_REGIONS_RIGHT_UPPER_ANDROID = 2, + XR_FACE_CONFIDENCE_REGIONS_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrFaceConfidenceRegionsANDROID; +typedef struct XrFaceTrackerCreateInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrFaceTrackerCreateInfoANDROID; + +typedef struct XrFaceStateGetInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrTime time; +} XrFaceStateGetInfoANDROID; + +typedef struct XrFaceStateANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t parametersCapacityInput; + uint32_t parametersCountOutput; + float* parameters; + XrFaceTrackingStateANDROID faceTrackingState; + XrTime sampleTime; + XrBool32 isValid; + uint32_t regionConfidencesCapacityInput; + uint32_t regionConfidencesCountOutput; + float* regionConfidences; +} XrFaceStateANDROID; + +// XrSystemFaceTrackingPropertiesANDROID extends XrSystemProperties +typedef struct XrSystemFaceTrackingPropertiesANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsFaceTracking; +} XrSystemFaceTrackingPropertiesANDROID; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateFaceTrackerANDROID)(XrSession session, const XrFaceTrackerCreateInfoANDROID* createInfo, XrFaceTrackerANDROID* faceTracker); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyFaceTrackerANDROID)(XrFaceTrackerANDROID faceTracker); +typedef XrResult (XRAPI_PTR *PFN_xrGetFaceStateANDROID)(XrFaceTrackerANDROID faceTracker, const XrFaceStateGetInfoANDROID* getInfo, XrFaceStateANDROID* faceStateOutput); +typedef XrResult (XRAPI_PTR *PFN_xrGetFaceCalibrationStateANDROID)(XrFaceTrackerANDROID faceTracker, XrBool32* faceIsCalibratedOutput); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateFaceTrackerANDROID( + XrSession session, + const XrFaceTrackerCreateInfoANDROID* createInfo, + XrFaceTrackerANDROID* faceTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyFaceTrackerANDROID( + XrFaceTrackerANDROID faceTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetFaceStateANDROID( + XrFaceTrackerANDROID faceTracker, + const XrFaceStateGetInfoANDROID* getInfo, + XrFaceStateANDROID* faceStateOutput); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetFaceCalibrationStateANDROID( + XrFaceTrackerANDROID faceTracker, + XrBool32* faceIsCalibratedOutput); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ANDROID_passthrough_camera_state is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_passthrough_camera_state 1 +#define XR_ANDROID_passthrough_camera_state_SPEC_VERSION 1 +#define XR_ANDROID_PASSTHROUGH_CAMERA_STATE_EXTENSION_NAME "XR_ANDROID_passthrough_camera_state" + +typedef enum XrPassthroughCameraStateANDROID { + XR_PASSTHROUGH_CAMERA_STATE_DISABLED_ANDROID = 0, + XR_PASSTHROUGH_CAMERA_STATE_INITIALIZING_ANDROID = 1, + XR_PASSTHROUGH_CAMERA_STATE_READY_ANDROID = 2, + XR_PASSTHROUGH_CAMERA_STATE_ERROR_ANDROID = 3, + XR_PASSTHROUGH_CAMERA_STATE_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrPassthroughCameraStateANDROID; +// XrSystemPassthroughCameraStatePropertiesANDROID extends XrSystemProperties +typedef struct XrSystemPassthroughCameraStatePropertiesANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsPassthroughCameraState; +} XrSystemPassthroughCameraStatePropertiesANDROID; + +typedef struct XrPassthroughCameraStateGetInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrPassthroughCameraStateGetInfoANDROID; + +typedef XrResult (XRAPI_PTR *PFN_xrGetPassthroughCameraStateANDROID)(XrSession session, const XrPassthroughCameraStateGetInfoANDROID* getInfo, XrPassthroughCameraStateANDROID* cameraStateOutput); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetPassthroughCameraStateANDROID( + XrSession session, + const XrPassthroughCameraStateGetInfoANDROID* getInfo, + XrPassthroughCameraStateANDROID* cameraStateOutput); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ANDROID_recommended_resolution is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_recommended_resolution 1 +#define XR_ANDROID_recommended_resolution_SPEC_VERSION 1 +#define XR_ANDROID_RECOMMENDED_RESOLUTION_EXTENSION_NAME "XR_ANDROID_recommended_resolution" +typedef struct XrEventDataRecommendedResolutionChangedANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrEventDataRecommendedResolutionChangedANDROID; + + + +// XR_ANDROID_composition_layer_passthrough_mesh is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_composition_layer_passthrough_mesh 1 +XR_DEFINE_HANDLE(XrPassthroughLayerANDROID) +#define XR_ANDROID_composition_layer_passthrough_mesh_SPEC_VERSION 1 +#define XR_ANDROID_COMPOSITION_LAYER_PASSTHROUGH_MESH_EXTENSION_NAME "XR_ANDROID_composition_layer_passthrough_mesh" + +typedef enum XrWindingOrderANDROID { + XR_WINDING_ORDER_UNKNOWN_ANDROID = 0, + XR_WINDING_ORDER_CW_ANDROID = 1, + XR_WINDING_ORDER_CCW_ANDROID = 2, + XR_WINDING_ORDER_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrWindingOrderANDROID; +typedef struct XrPassthroughLayerCreateInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t vertexCapacity; + uint32_t indexCapacity; +} XrPassthroughLayerCreateInfoANDROID; + +// XrPassthroughLayerMeshANDROID extends XrPassthroughLayerCreateInfoANDROID +typedef struct XrPassthroughLayerMeshANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrWindingOrderANDROID windingOrder; + uint32_t vertexCount; + const XrVector3f* vertices; + uint32_t indexCount; + const uint16_t* indices; +} XrPassthroughLayerMeshANDROID; + +typedef struct XrCompositionLayerPassthroughANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCompositionLayerFlags layerFlags; + XrSpace space; + XrPosef pose; + XrVector3f scale; + float opacity; + XrPassthroughLayerANDROID layer; +} XrCompositionLayerPassthroughANDROID; + +// XrSystemPassthroughLayerPropertiesANDROID extends XrSystemProperties +typedef struct XrSystemPassthroughLayerPropertiesANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsPassthroughLayer; + uint32_t maxMeshIndexCount; + uint32_t maxMeshVertexCount; +} XrSystemPassthroughLayerPropertiesANDROID; + +typedef XrResult (XRAPI_PTR *PFN_xrCreatePassthroughLayerANDROID)(XrSession session, const XrPassthroughLayerCreateInfoANDROID* createInfo, XrPassthroughLayerANDROID* layer); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyPassthroughLayerANDROID)(XrPassthroughLayerANDROID layer); +typedef XrResult (XRAPI_PTR *PFN_xrSetPassthroughLayerMeshANDROID)(XrPassthroughLayerANDROID layer, const XrPassthroughLayerMeshANDROID* mesh); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreatePassthroughLayerANDROID( + XrSession session, + const XrPassthroughLayerCreateInfoANDROID* createInfo, + XrPassthroughLayerANDROID* layer); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyPassthroughLayerANDROID( + XrPassthroughLayerANDROID layer); + +XRAPI_ATTR XrResult XRAPI_CALL xrSetPassthroughLayerMeshANDROID( + XrPassthroughLayerANDROID layer, + const XrPassthroughLayerMeshANDROID* mesh); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ANDROID_raycast is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_raycast 1 +#define XR_ANDROID_raycast_SPEC_VERSION 1 +#define XR_ANDROID_RAYCAST_EXTENSION_NAME "XR_ANDROID_raycast" +typedef struct XrRaycastInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t maxResults; + uint32_t trackerCount; + const XrTrackableTrackerANDROID* trackers; + XrVector3f origin; + XrVector3f trajectory; + XrSpace space; + XrTime time; +} XrRaycastInfoANDROID; + +typedef struct XrRaycastHitResultANDROID { + XrTrackableTypeANDROID type; + XrTrackableANDROID trackable; + XrPosef pose; +} XrRaycastHitResultANDROID; + +typedef struct XrRaycastHitResultsANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t resultsCapacityInput; + uint32_t resultsCountOutput; + XrRaycastHitResultANDROID* results; +} XrRaycastHitResultsANDROID; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateRaycastSupportedTrackableTypesANDROID)(XrInstance instance, XrSystemId systemId, uint32_t trackableTypeCapacityInput, uint32_t* trackableTypeCountOutput, XrTrackableTypeANDROID* trackableTypes); +typedef XrResult (XRAPI_PTR *PFN_xrRaycastANDROID)(XrSession session, const XrRaycastInfoANDROID* rayInfo, XrRaycastHitResultsANDROID* results); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateRaycastSupportedTrackableTypesANDROID( + XrInstance instance, + XrSystemId systemId, + uint32_t trackableTypeCapacityInput, + uint32_t* trackableTypeCountOutput, + XrTrackableTypeANDROID* trackableTypes); + +XRAPI_ATTR XrResult XRAPI_CALL xrRaycastANDROID( + XrSession session, + const XrRaycastInfoANDROID* rayInfo, + XrRaycastHitResultsANDROID* results); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ANDROID_performance_metrics is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_performance_metrics 1 +#define XR_ANDROID_performance_metrics_SPEC_VERSION 1 +#define XR_ANDROID_PERFORMANCE_METRICS_EXTENSION_NAME "XR_ANDROID_performance_metrics" + +typedef enum XrPerformanceMetricsCounterUnitANDROID { + XR_PERFORMANCE_METRICS_COUNTER_UNIT_GENERIC_ANDROID = 0, + XR_PERFORMANCE_METRICS_COUNTER_UNIT_PERCENTAGE_ANDROID = 1, + XR_PERFORMANCE_METRICS_COUNTER_UNIT_MILLISECONDS_ANDROID = 2, + XR_PERFORMANCE_METRICS_COUNTER_UNIT_BYTES_ANDROID = 3, + XR_PERFORMANCE_METRICS_COUNTER_UNIT_HERTZ_ANDROID = 4, + XR_PERFORMANCE_METRICS_COUNTER_UNIT_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrPerformanceMetricsCounterUnitANDROID; +typedef XrFlags64 XrPerformanceMetricsCounterFlagsANDROID; + +// Flag bits for XrPerformanceMetricsCounterFlagsANDROID +static const XrPerformanceMetricsCounterFlagsANDROID XR_PERFORMANCE_METRICS_COUNTER_ANY_VALUE_VALID_BIT_ANDROID = 0x00000001; +static const XrPerformanceMetricsCounterFlagsANDROID XR_PERFORMANCE_METRICS_COUNTER_UINT_VALUE_VALID_BIT_ANDROID = 0x00000002; +static const XrPerformanceMetricsCounterFlagsANDROID XR_PERFORMANCE_METRICS_COUNTER_FLOAT_VALUE_VALID_BIT_ANDROID = 0x00000004; + +typedef struct XrPerformanceMetricsStateANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 enabled; +} XrPerformanceMetricsStateANDROID; + +typedef struct XrPerformanceMetricsCounterANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrPerformanceMetricsCounterFlagsANDROID counterFlags; + XrPerformanceMetricsCounterUnitANDROID counterUnit; + uint32_t uintValue; + float floatValue; +} XrPerformanceMetricsCounterANDROID; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumeratePerformanceMetricsCounterPathsANDROID)(XrInstance instance, uint32_t counterPathCapacityInput, uint32_t* counterPathCountOutput, XrPath* counterPaths); +typedef XrResult (XRAPI_PTR *PFN_xrSetPerformanceMetricsStateANDROID)(XrSession session, const XrPerformanceMetricsStateANDROID* state); +typedef XrResult (XRAPI_PTR *PFN_xrGetPerformanceMetricsStateANDROID)(XrSession session, XrPerformanceMetricsStateANDROID* state); +typedef XrResult (XRAPI_PTR *PFN_xrQueryPerformanceMetricsCounterANDROID)(XrSession session, XrPath counterPath, XrPerformanceMetricsCounterANDROID* counter); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumeratePerformanceMetricsCounterPathsANDROID( + XrInstance instance, + uint32_t counterPathCapacityInput, + uint32_t* counterPathCountOutput, + XrPath* counterPaths); + +XRAPI_ATTR XrResult XRAPI_CALL xrSetPerformanceMetricsStateANDROID( + XrSession session, + const XrPerformanceMetricsStateANDROID* state); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetPerformanceMetricsStateANDROID( + XrSession session, + XrPerformanceMetricsStateANDROID* state); + +XRAPI_ATTR XrResult XRAPI_CALL xrQueryPerformanceMetricsCounterANDROID( + XrSession session, + XrPath counterPath, + XrPerformanceMetricsCounterANDROID* counter); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ANDROID_trackables_object is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_trackables_object 1 +#define XR_ANDROID_trackables_object_SPEC_VERSION 2 +#define XR_ANDROID_TRACKABLES_OBJECT_EXTENSION_NAME "XR_ANDROID_trackables_object" + +typedef enum XrObjectLabelANDROID { + XR_OBJECT_LABEL_UNKNOWN_ANDROID = 0, + XR_OBJECT_LABEL_KEYBOARD_ANDROID = 1, + XR_OBJECT_LABEL_MOUSE_ANDROID = 2, + XR_OBJECT_LABEL_LAPTOP_ANDROID = 3, + XR_OBJECT_LABEL_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrObjectLabelANDROID; +typedef struct XrTrackableObjectANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrTrackingStateANDROID trackingState; + XrPosef centerPose; + XrExtent3DfEXT extents; + XrObjectLabelANDROID objectLabel; + XrTime lastUpdatedTime; +} XrTrackableObjectANDROID; + +// XrTrackableObjectConfigurationANDROID extends XrTrackableTrackerCreateInfoANDROID +typedef struct XrTrackableObjectConfigurationANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t labelCount; + const XrObjectLabelANDROID* activeLabels; +} XrTrackableObjectConfigurationANDROID; + +typedef XrResult (XRAPI_PTR *PFN_xrGetTrackableObjectANDROID)(XrTrackableTrackerANDROID tracker, const XrTrackableGetInfoANDROID* getInfo, XrTrackableObjectANDROID* objectOutput); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetTrackableObjectANDROID( + XrTrackableTrackerANDROID tracker, + const XrTrackableGetInfoANDROID* getInfo, + XrTrackableObjectANDROID* objectOutput); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ANDROID_unbounded_reference_space is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_unbounded_reference_space 1 +#define XR_ANDROID_unbounded_reference_space_SPEC_VERSION 1 +#define XR_ANDROID_UNBOUNDED_REFERENCE_SPACE_EXTENSION_NAME "XR_ANDROID_unbounded_reference_space" + + +// XR_EXT_future is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_future 1 +#define XR_EXT_future_SPEC_VERSION 2 +#define XR_EXT_FUTURE_EXTENSION_NAME "XR_EXT_future" +#define XR_NULL_FUTURE_EXT 0 + +typedef enum XrFutureStateEXT { + XR_FUTURE_STATE_PENDING_EXT = 1, + XR_FUTURE_STATE_READY_EXT = 2, + XR_FUTURE_STATE_MAX_ENUM_EXT = 0x7FFFFFFF +} XrFutureStateEXT; +typedef struct XrFutureCancelInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrFutureEXT future; +} XrFutureCancelInfoEXT; + +typedef struct XrFuturePollInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrFutureEXT future; +} XrFuturePollInfoEXT; + +typedef struct XR_MAY_ALIAS XrFutureCompletionBaseHeaderEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrResult futureResult; +} XrFutureCompletionBaseHeaderEXT; + +typedef struct XrFuturePollResultEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrFutureStateEXT state; +} XrFuturePollResultEXT; + +typedef XrResult (XRAPI_PTR *PFN_xrPollFutureEXT)(XrInstance instance, const XrFuturePollInfoEXT* pollInfo, XrFuturePollResultEXT* pollResult); +typedef XrResult (XRAPI_PTR *PFN_xrCancelFutureEXT)(XrInstance instance, const XrFutureCancelInfoEXT* cancelInfo); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrPollFutureEXT( + XrInstance instance, + const XrFuturePollInfoEXT* pollInfo, + XrFuturePollResultEXT* pollResult); + +XRAPI_ATTR XrResult XRAPI_CALL xrCancelFutureEXT( + XrInstance instance, + const XrFutureCancelInfoEXT* cancelInfo); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_EXT_user_presence is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_user_presence 1 +#define XR_EXT_user_presence_SPEC_VERSION 1 +#define XR_EXT_USER_PRESENCE_EXTENSION_NAME "XR_EXT_user_presence" +typedef struct XrEventDataUserPresenceChangedEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSession session; + XrBool32 isUserPresent; +} XrEventDataUserPresenceChangedEXT; + +// XrSystemUserPresencePropertiesEXT extends XrSystemProperties +typedef struct XrSystemUserPresencePropertiesEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsUserPresence; +} XrSystemUserPresencePropertiesEXT; + + + +// XR_ML_user_calibration is a preprocessor guard. Do not pass it to API calls. +#define XR_ML_user_calibration 1 +#define XR_ML_user_calibration_SPEC_VERSION 1 +#define XR_ML_USER_CALIBRATION_EXTENSION_NAME "XR_ML_user_calibration" + +typedef enum XrHeadsetFitStatusML { + XR_HEADSET_FIT_STATUS_UNKNOWN_ML = 0, + XR_HEADSET_FIT_STATUS_NOT_WORN_ML = 1, + XR_HEADSET_FIT_STATUS_GOOD_FIT_ML = 2, + XR_HEADSET_FIT_STATUS_BAD_FIT_ML = 3, + XR_HEADSET_FIT_STATUS_MAX_ENUM_ML = 0x7FFFFFFF +} XrHeadsetFitStatusML; + +typedef enum XrEyeCalibrationStatusML { + XR_EYE_CALIBRATION_STATUS_UNKNOWN_ML = 0, + XR_EYE_CALIBRATION_STATUS_NONE_ML = 1, + XR_EYE_CALIBRATION_STATUS_COARSE_ML = 2, + XR_EYE_CALIBRATION_STATUS_FINE_ML = 3, + XR_EYE_CALIBRATION_STATUS_MAX_ENUM_ML = 0x7FFFFFFF +} XrEyeCalibrationStatusML; +typedef struct XrEventDataHeadsetFitChangedML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrHeadsetFitStatusML status; + XrTime time; +} XrEventDataHeadsetFitChangedML; + +typedef struct XrEventDataEyeCalibrationChangedML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrEyeCalibrationStatusML status; +} XrEventDataEyeCalibrationChangedML; + +typedef struct XrUserCalibrationEnableEventsInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 enabled; +} XrUserCalibrationEnableEventsInfoML; + +typedef XrResult (XRAPI_PTR *PFN_xrEnableUserCalibrationEventsML)(XrInstance instance, const XrUserCalibrationEnableEventsInfoML* enableInfo); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnableUserCalibrationEventsML( + XrInstance instance, + const XrUserCalibrationEnableEventsInfoML* enableInfo); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ML_system_notifications is a preprocessor guard. Do not pass it to API calls. +#define XR_ML_system_notifications 1 +#define XR_ML_system_notifications_SPEC_VERSION 1 +#define XR_ML_SYSTEM_NOTIFICATIONS_EXTENSION_NAME "XR_ML_system_notifications" +typedef struct XrSystemNotificationsSetInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 suppressNotifications; +} XrSystemNotificationsSetInfoML; + +typedef XrResult (XRAPI_PTR *PFN_xrSetSystemNotificationsML)(XrInstance instance, const XrSystemNotificationsSetInfoML* info); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrSetSystemNotificationsML( + XrInstance instance, + const XrSystemNotificationsSetInfoML* info); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ML_world_mesh_detection is a preprocessor guard. Do not pass it to API calls. +#define XR_ML_world_mesh_detection 1 +XR_DEFINE_HANDLE(XrWorldMeshDetectorML) +#define XR_ML_world_mesh_detection_SPEC_VERSION 1 +#define XR_ML_WORLD_MESH_DETECTION_EXTENSION_NAME "XR_ML_world_mesh_detection" + +typedef enum XrWorldMeshDetectorLodML { + XR_WORLD_MESH_DETECTOR_LOD_MINIMUM_ML = 0, + XR_WORLD_MESH_DETECTOR_LOD_MEDIUM_ML = 1, + XR_WORLD_MESH_DETECTOR_LOD_MAXIMUM_ML = 2, + XR_WORLD_MESH_DETECTOR_LOD_MAX_ENUM_ML = 0x7FFFFFFF +} XrWorldMeshDetectorLodML; + +typedef enum XrWorldMeshBlockStatusML { + XR_WORLD_MESH_BLOCK_STATUS_NEW_ML = 0, + XR_WORLD_MESH_BLOCK_STATUS_UPDATED_ML = 1, + XR_WORLD_MESH_BLOCK_STATUS_DELETED_ML = 2, + XR_WORLD_MESH_BLOCK_STATUS_UNCHANGED_ML = 3, + XR_WORLD_MESH_BLOCK_STATUS_MAX_ENUM_ML = 0x7FFFFFFF +} XrWorldMeshBlockStatusML; + +typedef enum XrWorldMeshBlockResultML { + XR_WORLD_MESH_BLOCK_RESULT_SUCCESS_ML = 0, + XR_WORLD_MESH_BLOCK_RESULT_FAILED_ML = 1, + XR_WORLD_MESH_BLOCK_RESULT_PENDING_ML = 2, + XR_WORLD_MESH_BLOCK_RESULT_PARTIAL_UPDATE_ML = 3, + XR_WORLD_MESH_BLOCK_RESULT_MAX_ENUM_ML = 0x7FFFFFFF +} XrWorldMeshBlockResultML; +typedef XrFlags64 XrWorldMeshDetectorFlagsML; + +// Flag bits for XrWorldMeshDetectorFlagsML +static const XrWorldMeshDetectorFlagsML XR_WORLD_MESH_DETECTOR_POINT_CLOUD_BIT_ML = 0x00000001; +static const XrWorldMeshDetectorFlagsML XR_WORLD_MESH_DETECTOR_COMPUTE_NORMALS_BIT_ML = 0x00000002; +static const XrWorldMeshDetectorFlagsML XR_WORLD_MESH_DETECTOR_COMPUTE_CONFIDENCE_BIT_ML = 0x00000004; +static const XrWorldMeshDetectorFlagsML XR_WORLD_MESH_DETECTOR_PLANARIZE_BIT_ML = 0x00000008; +static const XrWorldMeshDetectorFlagsML XR_WORLD_MESH_DETECTOR_REMOVE_MESH_SKIRT_BIT_ML = 0x00000010; +static const XrWorldMeshDetectorFlagsML XR_WORLD_MESH_DETECTOR_INDEX_ORDER_CW_BIT_ML = 0x00000020; + +typedef struct XrWorldMeshDetectorCreateInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrWorldMeshDetectorCreateInfoML; + +typedef struct XrWorldMeshBlockStateML { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrUuidEXT uuid; + XrPosef meshBoundingBoxCenter; + XrExtent3DfEXT meshBoundingBoxExtents; + XrTime lastUpdateTime; + XrWorldMeshBlockStatusML status; +} XrWorldMeshBlockStateML; + +typedef struct XrWorldMeshStateRequestInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace baseSpace; + XrTime time; + XrPosef boundingBoxCenter; + XrExtent3DfEXT boundingBoxExtents; +} XrWorldMeshStateRequestInfoML; + +typedef struct XrWorldMeshStateRequestCompletionML { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrResult futureResult; + XrTime timestamp; + uint32_t meshBlockStateCapacityInput; + uint32_t meshBlockStateCountOutput; + XrWorldMeshBlockStateML* meshBlockStates; +} XrWorldMeshStateRequestCompletionML; + +typedef struct XrWorldMeshBufferRecommendedSizeInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t maxBlockCount; +} XrWorldMeshBufferRecommendedSizeInfoML; + +typedef struct XrWorldMeshBufferSizeML { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t size; +} XrWorldMeshBufferSizeML; + +typedef struct XrWorldMeshBufferML { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t bufferSize; + void* XR_MAY_ALIAS buffer; +} XrWorldMeshBufferML; + +typedef struct XrWorldMeshBlockRequestML { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrUuidEXT uuid; + XrWorldMeshDetectorLodML lod; +} XrWorldMeshBlockRequestML; + +typedef struct XrWorldMeshGetInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrWorldMeshDetectorFlagsML flags; + float fillHoleLength; + float disconnectedComponentArea; + uint32_t blockCount; + XrWorldMeshBlockRequestML* blocks; +} XrWorldMeshGetInfoML; + +typedef struct XrWorldMeshBlockML { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrUuidEXT uuid; + XrWorldMeshBlockResultML blockResult; + XrWorldMeshDetectorLodML lod; + XrWorldMeshDetectorFlagsML flags; + uint32_t indexCount; + uint16_t* indexBuffer; + uint32_t vertexCount; + XrVector3f* vertexBuffer; + uint32_t normalCount; + XrVector3f* normalBuffer; + uint32_t confidenceCount; + float* confidenceBuffer; +} XrWorldMeshBlockML; + +typedef struct XrWorldMeshRequestCompletionInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace meshSpace; + XrTime meshSpaceLocateTime; +} XrWorldMeshRequestCompletionInfoML; + +typedef struct XrWorldMeshRequestCompletionML { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrResult futureResult; + uint32_t blockCount; + XrWorldMeshBlockML* blocks; +} XrWorldMeshRequestCompletionML; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateWorldMeshDetectorML)(XrSession session, const XrWorldMeshDetectorCreateInfoML* createInfo, XrWorldMeshDetectorML* detector); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyWorldMeshDetectorML)(XrWorldMeshDetectorML detector); +typedef XrResult (XRAPI_PTR *PFN_xrRequestWorldMeshStateAsyncML)(XrWorldMeshDetectorML detector, const XrWorldMeshStateRequestInfoML* stateRequest, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrRequestWorldMeshStateCompleteML)(XrWorldMeshDetectorML detector, XrFutureEXT future, XrWorldMeshStateRequestCompletionML* completion); +typedef XrResult (XRAPI_PTR *PFN_xrGetWorldMeshBufferRecommendSizeML)(XrWorldMeshDetectorML detector, const XrWorldMeshBufferRecommendedSizeInfoML* sizeInfo, XrWorldMeshBufferSizeML* size); +typedef XrResult (XRAPI_PTR *PFN_xrAllocateWorldMeshBufferML)(XrWorldMeshDetectorML detector, const XrWorldMeshBufferSizeML* size, XrWorldMeshBufferML* buffer); +typedef XrResult (XRAPI_PTR *PFN_xrFreeWorldMeshBufferML)(XrWorldMeshDetectorML detector, const XrWorldMeshBufferML* buffer); +typedef XrResult (XRAPI_PTR *PFN_xrRequestWorldMeshAsyncML)(XrWorldMeshDetectorML detector, const XrWorldMeshGetInfoML* getInfo, XrWorldMeshBufferML* buffer, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrRequestWorldMeshCompleteML)(XrWorldMeshDetectorML detector, const XrWorldMeshRequestCompletionInfoML* completionInfo, XrFutureEXT future, XrWorldMeshRequestCompletionML* completion); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateWorldMeshDetectorML( + XrSession session, + const XrWorldMeshDetectorCreateInfoML* createInfo, + XrWorldMeshDetectorML* detector); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyWorldMeshDetectorML( + XrWorldMeshDetectorML detector); + +XRAPI_ATTR XrResult XRAPI_CALL xrRequestWorldMeshStateAsyncML( + XrWorldMeshDetectorML detector, + const XrWorldMeshStateRequestInfoML* stateRequest, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrRequestWorldMeshStateCompleteML( + XrWorldMeshDetectorML detector, + XrFutureEXT future, + XrWorldMeshStateRequestCompletionML* completion); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetWorldMeshBufferRecommendSizeML( + XrWorldMeshDetectorML detector, + const XrWorldMeshBufferRecommendedSizeInfoML* sizeInfo, + XrWorldMeshBufferSizeML* size); + +XRAPI_ATTR XrResult XRAPI_CALL xrAllocateWorldMeshBufferML( + XrWorldMeshDetectorML detector, + const XrWorldMeshBufferSizeML* size, + XrWorldMeshBufferML* buffer); + +XRAPI_ATTR XrResult XRAPI_CALL xrFreeWorldMeshBufferML( + XrWorldMeshDetectorML detector, + const XrWorldMeshBufferML* buffer); + +XRAPI_ATTR XrResult XRAPI_CALL xrRequestWorldMeshAsyncML( + XrWorldMeshDetectorML detector, + const XrWorldMeshGetInfoML* getInfo, + XrWorldMeshBufferML* buffer, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrRequestWorldMeshCompleteML( + XrWorldMeshDetectorML detector, + const XrWorldMeshRequestCompletionInfoML* completionInfo, + XrFutureEXT future, + XrWorldMeshRequestCompletionML* completion); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ML_facial_expression is a preprocessor guard. Do not pass it to API calls. +#define XR_ML_facial_expression 1 +XR_DEFINE_HANDLE(XrFacialExpressionClientML) +#define XR_ML_facial_expression_SPEC_VERSION 1 +#define XR_ML_FACIAL_EXPRESSION_EXTENSION_NAME "XR_ML_facial_expression" + +typedef enum XrFacialBlendShapeML { + XR_FACIAL_BLEND_SHAPE_BROW_LOWERER_L_ML = 0, + XR_FACIAL_BLEND_SHAPE_BROW_LOWERER_R_ML = 1, + XR_FACIAL_BLEND_SHAPE_CHEEK_RAISER_L_ML = 2, + XR_FACIAL_BLEND_SHAPE_CHEEK_RAISER_R_ML = 3, + XR_FACIAL_BLEND_SHAPE_CHIN_RAISER_ML = 4, + XR_FACIAL_BLEND_SHAPE_DIMPLER_L_ML = 5, + XR_FACIAL_BLEND_SHAPE_DIMPLER_R_ML = 6, + XR_FACIAL_BLEND_SHAPE_EYES_CLOSED_L_ML = 7, + XR_FACIAL_BLEND_SHAPE_EYES_CLOSED_R_ML = 8, + XR_FACIAL_BLEND_SHAPE_INNER_BROW_RAISER_L_ML = 9, + XR_FACIAL_BLEND_SHAPE_INNER_BROW_RAISER_R_ML = 10, + XR_FACIAL_BLEND_SHAPE_JAW_DROP_ML = 11, + XR_FACIAL_BLEND_SHAPE_LID_TIGHTENER_L_ML = 12, + XR_FACIAL_BLEND_SHAPE_LID_TIGHTENER_R_ML = 13, + XR_FACIAL_BLEND_SHAPE_LIP_CORNER_DEPRESSOR_L_ML = 14, + XR_FACIAL_BLEND_SHAPE_LIP_CORNER_DEPRESSOR_R_ML = 15, + XR_FACIAL_BLEND_SHAPE_LIP_CORNER_PULLER_L_ML = 16, + XR_FACIAL_BLEND_SHAPE_LIP_CORNER_PULLER_R_ML = 17, + XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_LB_ML = 18, + XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_LT_ML = 19, + XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_RB_ML = 20, + XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_RT_ML = 21, + XR_FACIAL_BLEND_SHAPE_LIP_PRESSOR_L_ML = 22, + XR_FACIAL_BLEND_SHAPE_LIP_PRESSOR_R_ML = 23, + XR_FACIAL_BLEND_SHAPE_LIP_PUCKER_L_ML = 24, + XR_FACIAL_BLEND_SHAPE_LIP_PUCKER_R_ML = 25, + XR_FACIAL_BLEND_SHAPE_LIP_STRETCHER_L_ML = 26, + XR_FACIAL_BLEND_SHAPE_LIP_STRETCHER_R_ML = 27, + XR_FACIAL_BLEND_SHAPE_LIP_SUCK_LB_ML = 28, + XR_FACIAL_BLEND_SHAPE_LIP_SUCK_LT_ML = 29, + XR_FACIAL_BLEND_SHAPE_LIP_SUCK_RB_ML = 30, + XR_FACIAL_BLEND_SHAPE_LIP_SUCK_RT_ML = 31, + XR_FACIAL_BLEND_SHAPE_LIP_TIGHTENER_L_ML = 32, + XR_FACIAL_BLEND_SHAPE_LIP_TIGHTENER_R_ML = 33, + XR_FACIAL_BLEND_SHAPE_LIPS_TOWARD_ML = 34, + XR_FACIAL_BLEND_SHAPE_LOWER_LIP_DEPRESSOR_L_ML = 35, + XR_FACIAL_BLEND_SHAPE_LOWER_LIP_DEPRESSOR_R_ML = 36, + XR_FACIAL_BLEND_SHAPE_NOSE_WRINKLER_L_ML = 37, + XR_FACIAL_BLEND_SHAPE_NOSE_WRINKLER_R_ML = 38, + XR_FACIAL_BLEND_SHAPE_OUTER_BROW_RAISER_L_ML = 39, + XR_FACIAL_BLEND_SHAPE_OUTER_BROW_RAISER_R_ML = 40, + XR_FACIAL_BLEND_SHAPE_UPPER_LID_RAISER_L_ML = 41, + XR_FACIAL_BLEND_SHAPE_UPPER_LID_RAISER_R_ML = 42, + XR_FACIAL_BLEND_SHAPE_UPPER_LIP_RAISER_L_ML = 43, + XR_FACIAL_BLEND_SHAPE_UPPER_LIP_RAISER_R_ML = 44, + XR_FACIAL_BLEND_SHAPE_TONGUE_OUT_ML = 45, + XR_FACIAL_BLEND_SHAPE_MAX_ENUM_ML = 0x7FFFFFFF +} XrFacialBlendShapeML; +typedef XrFlags64 XrFacialExpressionBlendShapePropertiesFlagsML; + +// Flag bits for XrFacialExpressionBlendShapePropertiesFlagsML +static const XrFacialExpressionBlendShapePropertiesFlagsML XR_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_VALID_BIT_ML = 0x00000001; +static const XrFacialExpressionBlendShapePropertiesFlagsML XR_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_TRACKED_BIT_ML = 0x00000002; + +// XrSystemFacialExpressionPropertiesML extends XrSystemProperties +typedef struct XrSystemFacialExpressionPropertiesML { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsFacialExpression; +} XrSystemFacialExpressionPropertiesML; + +typedef struct XrFacialExpressionClientCreateInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t requestedCount; + const XrFacialBlendShapeML* requestedFacialBlendShapes; +} XrFacialExpressionClientCreateInfoML; + +typedef struct XrFacialExpressionBlendShapeGetInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrFacialExpressionBlendShapeGetInfoML; + +typedef struct XrFacialExpressionBlendShapePropertiesML { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrFacialBlendShapeML requestedFacialBlendShape; + float weight; + XrFacialExpressionBlendShapePropertiesFlagsML flags; + XrTime time; +} XrFacialExpressionBlendShapePropertiesML; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateFacialExpressionClientML)(XrSession session, const XrFacialExpressionClientCreateInfoML* createInfo, XrFacialExpressionClientML* facialExpressionClient); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyFacialExpressionClientML)(XrFacialExpressionClientML facialExpressionClient); +typedef XrResult (XRAPI_PTR *PFN_xrGetFacialExpressionBlendShapePropertiesML)(XrFacialExpressionClientML facialExpressionClient, const XrFacialExpressionBlendShapeGetInfoML* blendShapeGetInfo, uint32_t blendShapeCount, XrFacialExpressionBlendShapePropertiesML* blendShapes); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateFacialExpressionClientML( + XrSession session, + const XrFacialExpressionClientCreateInfoML* createInfo, + XrFacialExpressionClientML* facialExpressionClient); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyFacialExpressionClientML( + XrFacialExpressionClientML facialExpressionClient); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetFacialExpressionBlendShapePropertiesML( + XrFacialExpressionClientML facialExpressionClient, + const XrFacialExpressionBlendShapeGetInfoML* blendShapeGetInfo, + uint32_t blendShapeCount, + XrFacialExpressionBlendShapePropertiesML* blendShapes); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ML_view_configuration_depth_range_change is a preprocessor guard. Do not pass it to API calls. +#define XR_ML_view_configuration_depth_range_change 1 +#define XR_ML_view_configuration_depth_range_change_SPEC_VERSION 1 +#define XR_ML_VIEW_CONFIGURATION_DEPTH_RANGE_CHANGE_EXTENSION_NAME "XR_ML_view_configuration_depth_range_change" + + +// XR_YVR_controller_interaction is a preprocessor guard. Do not pass it to API calls. +#define XR_YVR_controller_interaction 1 +#define XR_YVR_controller_interaction_SPEC_VERSION 1 +#define XR_YVR_CONTROLLER_INTERACTION_EXTENSION_NAME "XR_YVR_controller_interaction" + + +// XR_META_boundary_visibility is a preprocessor guard. Do not pass it to API calls. +#define XR_META_boundary_visibility 1 +#define XR_META_boundary_visibility_SPEC_VERSION 1 +#define XR_META_BOUNDARY_VISIBILITY_EXTENSION_NAME "XR_META_boundary_visibility" + +typedef enum XrBoundaryVisibilityMETA { + XR_BOUNDARY_VISIBILITY_NOT_SUPPRESSED_META = 1, + XR_BOUNDARY_VISIBILITY_SUPPRESSED_META = 2, + XR_BOUNDARY_VISIBILITY_MAX_ENUM_META = 0x7FFFFFFF +} XrBoundaryVisibilityMETA; +// XrSystemBoundaryVisibilityPropertiesMETA extends XrSystemProperties +typedef struct XrSystemBoundaryVisibilityPropertiesMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsBoundaryVisibility; +} XrSystemBoundaryVisibilityPropertiesMETA; + +typedef struct XrEventDataBoundaryVisibilityChangedMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBoundaryVisibilityMETA boundaryVisibility; +} XrEventDataBoundaryVisibilityChangedMETA; + +typedef XrResult (XRAPI_PTR *PFN_xrRequestBoundaryVisibilityMETA)(XrSession session, XrBoundaryVisibilityMETA boundaryVisibility); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrRequestBoundaryVisibilityMETA( + XrSession session, + XrBoundaryVisibilityMETA boundaryVisibility); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_META_simultaneous_hands_and_controllers is a preprocessor guard. Do not pass it to API calls. +#define XR_META_simultaneous_hands_and_controllers 1 +#define XR_META_simultaneous_hands_and_controllers_SPEC_VERSION 1 +#define XR_META_SIMULTANEOUS_HANDS_AND_CONTROLLERS_EXTENSION_NAME "XR_META_simultaneous_hands_and_controllers" +// XrSystemSimultaneousHandsAndControllersPropertiesMETA extends XrSystemProperties +typedef struct XrSystemSimultaneousHandsAndControllersPropertiesMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsSimultaneousHandsAndControllers; +} XrSystemSimultaneousHandsAndControllersPropertiesMETA; + +typedef struct XrSimultaneousHandsAndControllersTrackingResumeInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrSimultaneousHandsAndControllersTrackingResumeInfoMETA; + +typedef struct XrSimultaneousHandsAndControllersTrackingPauseInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrSimultaneousHandsAndControllersTrackingPauseInfoMETA; + +typedef XrResult (XRAPI_PTR *PFN_xrResumeSimultaneousHandsAndControllersTrackingMETA)(XrSession session, const XrSimultaneousHandsAndControllersTrackingResumeInfoMETA* resumeInfo); +typedef XrResult (XRAPI_PTR *PFN_xrPauseSimultaneousHandsAndControllersTrackingMETA)(XrSession session, const XrSimultaneousHandsAndControllersTrackingPauseInfoMETA* pauseInfo); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrResumeSimultaneousHandsAndControllersTrackingMETA( + XrSession session, + const XrSimultaneousHandsAndControllersTrackingResumeInfoMETA* resumeInfo); + +XRAPI_ATTR XrResult XRAPI_CALL xrPauseSimultaneousHandsAndControllersTrackingMETA( + XrSession session, + const XrSimultaneousHandsAndControllersTrackingPauseInfoMETA* pauseInfo); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_META_face_tracking_visemes is a preprocessor guard. Do not pass it to API calls. +#define XR_META_face_tracking_visemes 1 +#define XR_FACE_TRACKING_VISEME_COUNT_META 15 +#define XR_META_face_tracking_visemes_SPEC_VERSION 1 +#define XR_META_FACE_TRACKING_VISEMES_EXTENSION_NAME "XR_META_face_tracking_visemes" + +typedef enum XrFaceTrackingVisemeMETA { + XR_FACE_TRACKING_VISEME_SIL_META = 0, + XR_FACE_TRACKING_VISEME_PP_META = 1, + XR_FACE_TRACKING_VISEME_FF_META = 2, + XR_FACE_TRACKING_VISEME_TH_META = 3, + XR_FACE_TRACKING_VISEME_DD_META = 4, + XR_FACE_TRACKING_VISEME_KK_META = 5, + XR_FACE_TRACKING_VISEME_CH_META = 6, + XR_FACE_TRACKING_VISEME_SS_META = 7, + XR_FACE_TRACKING_VISEME_NN_META = 8, + XR_FACE_TRACKING_VISEME_RR_META = 9, + XR_FACE_TRACKING_VISEME_AA_META = 10, + XR_FACE_TRACKING_VISEME_E_META = 11, + XR_FACE_TRACKING_VISEME_IH_META = 12, + XR_FACE_TRACKING_VISEME_OH_META = 13, + XR_FACE_TRACKING_VISEME_OU_META = 14, + XR_FACE_TRACKING_VISEME_MAX_ENUM_META = 0x7FFFFFFF +} XrFaceTrackingVisemeMETA; +// XrFaceTrackingVisemesMETA extends XrFaceExpressionWeights2FB +typedef struct XrFaceTrackingVisemesMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 isValid; + float visemes[XR_FACE_TRACKING_VISEME_COUNT_META]; +} XrFaceTrackingVisemesMETA; + +// XrSystemFaceTrackingVisemesPropertiesMETA extends XrSystemProperties +typedef struct XrSystemFaceTrackingVisemesPropertiesMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsVisemes; +} XrSystemFaceTrackingVisemesPropertiesMETA; + + + +// XR_META_spatial_entity_semantic_label is a preprocessor guard. Do not pass it to API calls. +#define XR_META_spatial_entity_semantic_label 1 +#define XR_META_spatial_entity_semantic_label_SPEC_VERSION 1 +#define XR_META_SPATIAL_ENTITY_SEMANTIC_LABEL_EXTENSION_NAME "XR_META_spatial_entity_semantic_label" + +typedef enum XrSemanticLabelMETA { + XR_SEMANTIC_LABEL_UNKNOWN_META = 0, + XR_SEMANTIC_LABEL_FLOOR_META = 1, + XR_SEMANTIC_LABEL_CEILING_META = 2, + XR_SEMANTIC_LABEL_WALL_FACE_META = 3, + XR_SEMANTIC_LABEL_INNER_WALL_FACE_META = 4, + XR_SEMANTIC_LABEL_INVISIBLE_WALL_FACE_META = 5, + XR_SEMANTIC_LABEL_DOOR_FRAME_META = 6, + XR_SEMANTIC_LABEL_WINDOW_FRAME_META = 7, + XR_SEMANTIC_LABEL_MAX_ENUM_META = 0x7FFFFFFF +} XrSemanticLabelMETA; + + +// XR_META_spatial_entity_room_mesh is a preprocessor guard. Do not pass it to API calls. +#define XR_META_spatial_entity_room_mesh 1 +#define XR_META_spatial_entity_room_mesh_SPEC_VERSION 1 +#define XR_META_SPATIAL_ENTITY_ROOM_MESH_EXTENSION_NAME "XR_META_spatial_entity_room_mesh" +typedef struct XrRoomMeshFaceMETA { + XrUuid uuid; + XrUuid parentUuid; + XrSemanticLabelMETA semanticLabel; +} XrRoomMeshFaceMETA; + +typedef struct XrRoomMeshFaceIndicesMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t indexCapacityInput; + uint32_t indexCountOutput; + uint32_t* indices; +} XrRoomMeshFaceIndicesMETA; + +typedef struct XrSpaceRoomMeshGetInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t recognizedSemanticLabelCount; + const XrSemanticLabelMETA* recognizedSemanticLabels; +} XrSpaceRoomMeshGetInfoMETA; + +typedef struct XrRoomMeshMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t vertexCapacityInput; + uint32_t vertexCountOutput; + XrVector3f* vertices; + uint32_t faceCapacityInput; + uint32_t faceCountOutput; + XrRoomMeshFaceMETA* faces; +} XrRoomMeshMETA; + +typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceRoomMeshMETA)(XrSpace space, const XrSpaceRoomMeshGetInfoMETA* getInfo, XrRoomMeshMETA* roomMeshOutput); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpaceRoomMeshFaceIndicesMETA)(XrSpace space, const XrUuid* faceUuid, XrRoomMeshFaceIndicesMETA* roomMeshFaceIndicesOutput); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceRoomMeshMETA( + XrSpace space, + const XrSpaceRoomMeshGetInfoMETA* getInfo, + XrRoomMeshMETA* roomMeshOutput); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpaceRoomMeshFaceIndicesMETA( + XrSpace space, + const XrUuid* faceUuid, + XrRoomMeshFaceIndicesMETA* roomMeshFaceIndicesOutput); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_EXT_composition_layer_inverted_alpha is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_composition_layer_inverted_alpha 1 +#define XR_EXT_composition_layer_inverted_alpha_SPEC_VERSION 1 +#define XR_EXT_COMPOSITION_LAYER_INVERTED_ALPHA_EXTENSION_NAME "XR_EXT_composition_layer_inverted_alpha" + + +// XR_META_colocation_discovery is a preprocessor guard. Do not pass it to API calls. +#define XR_META_colocation_discovery 1 +#define XR_MAX_COLOCATION_DISCOVERY_BUFFER_SIZE_META 1024 +#define XR_META_colocation_discovery_SPEC_VERSION 1 +#define XR_META_COLOCATION_DISCOVERY_EXTENSION_NAME "XR_META_colocation_discovery" +typedef struct XrColocationDiscoveryStartInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrColocationDiscoveryStartInfoMETA; + +typedef struct XrColocationDiscoveryStopInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrColocationDiscoveryStopInfoMETA; + +typedef struct XrColocationAdvertisementStartInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t bufferSize; + uint8_t* buffer; +} XrColocationAdvertisementStartInfoMETA; + +typedef struct XrColocationAdvertisementStopInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrColocationAdvertisementStopInfoMETA; + +typedef struct XrEventDataStartColocationAdvertisementCompleteMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAsyncRequestIdFB advertisementRequestId; + XrResult result; + XrUuid advertisementUuid; +} XrEventDataStartColocationAdvertisementCompleteMETA; + +typedef struct XrEventDataStopColocationAdvertisementCompleteMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAsyncRequestIdFB requestId; + XrResult result; +} XrEventDataStopColocationAdvertisementCompleteMETA; + +typedef struct XrEventDataColocationAdvertisementCompleteMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAsyncRequestIdFB advertisementRequestId; + XrResult result; +} XrEventDataColocationAdvertisementCompleteMETA; + +typedef struct XrEventDataStartColocationDiscoveryCompleteMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAsyncRequestIdFB discoveryRequestId; + XrResult result; +} XrEventDataStartColocationDiscoveryCompleteMETA; + +typedef struct XrEventDataColocationDiscoveryResultMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAsyncRequestIdFB discoveryRequestId; + XrUuid advertisementUuid; + uint32_t bufferSize; + uint8_t buffer[XR_MAX_COLOCATION_DISCOVERY_BUFFER_SIZE_META]; +} XrEventDataColocationDiscoveryResultMETA; + +typedef struct XrEventDataColocationDiscoveryCompleteMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAsyncRequestIdFB discoveryRequestId; + XrResult result; +} XrEventDataColocationDiscoveryCompleteMETA; + +typedef struct XrEventDataStopColocationDiscoveryCompleteMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAsyncRequestIdFB requestId; + XrResult result; +} XrEventDataStopColocationDiscoveryCompleteMETA; + +// XrSystemColocationDiscoveryPropertiesMETA extends XrSystemProperties +typedef struct XrSystemColocationDiscoveryPropertiesMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsColocationDiscovery; +} XrSystemColocationDiscoveryPropertiesMETA; + +typedef XrResult (XRAPI_PTR *PFN_xrStartColocationDiscoveryMETA)(XrSession session, const XrColocationDiscoveryStartInfoMETA* info, XrAsyncRequestIdFB* discoveryRequestId); +typedef XrResult (XRAPI_PTR *PFN_xrStopColocationDiscoveryMETA)(XrSession session, const XrColocationDiscoveryStopInfoMETA* info, XrAsyncRequestIdFB* requestId); +typedef XrResult (XRAPI_PTR *PFN_xrStartColocationAdvertisementMETA)(XrSession session, const XrColocationAdvertisementStartInfoMETA* info, XrAsyncRequestIdFB* advertisementRequestId); +typedef XrResult (XRAPI_PTR *PFN_xrStopColocationAdvertisementMETA)(XrSession session, const XrColocationAdvertisementStopInfoMETA* info, XrAsyncRequestIdFB* requestId); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrStartColocationDiscoveryMETA( + XrSession session, + const XrColocationDiscoveryStartInfoMETA* info, + XrAsyncRequestIdFB* discoveryRequestId); + +XRAPI_ATTR XrResult XRAPI_CALL xrStopColocationDiscoveryMETA( + XrSession session, + const XrColocationDiscoveryStopInfoMETA* info, + XrAsyncRequestIdFB* requestId); + +XRAPI_ATTR XrResult XRAPI_CALL xrStartColocationAdvertisementMETA( + XrSession session, + const XrColocationAdvertisementStartInfoMETA* info, + XrAsyncRequestIdFB* advertisementRequestId); + +XRAPI_ATTR XrResult XRAPI_CALL xrStopColocationAdvertisementMETA( + XrSession session, + const XrColocationAdvertisementStopInfoMETA* info, + XrAsyncRequestIdFB* requestId); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_META_spatial_entity_group_sharing is a preprocessor guard. Do not pass it to API calls. +#define XR_META_spatial_entity_group_sharing 1 +#define XR_META_spatial_entity_group_sharing_SPEC_VERSION 1 +#define XR_META_SPATIAL_ENTITY_GROUP_SHARING_EXTENSION_NAME "XR_META_spatial_entity_group_sharing" +// XrSystemSpatialEntityGroupSharingPropertiesMETA extends XrSystemProperties +typedef struct XrSystemSpatialEntityGroupSharingPropertiesMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsSpatialEntityGroupSharing; +} XrSystemSpatialEntityGroupSharingPropertiesMETA; + +typedef struct XrShareSpacesRecipientGroupsMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t groupCount; + XrUuid* groups; +} XrShareSpacesRecipientGroupsMETA; + +// XrSpaceGroupUuidFilterInfoMETA extends XrSpaceQueryInfoBaseHeaderFB +typedef struct XrSpaceGroupUuidFilterInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrUuid groupUuid; +} XrSpaceGroupUuidFilterInfoMETA; + + + +// XR_META_environment_raycast is a preprocessor guard. Do not pass it to API calls. +#define XR_META_environment_raycast 1 +XR_DEFINE_HANDLE(XrEnvironmentRaycasterMETA) +#define XR_META_environment_raycast_SPEC_VERSION 1 +#define XR_META_ENVIRONMENT_RAYCAST_EXTENSION_NAME "XR_META_environment_raycast" + +typedef enum XrEnvironmentRaycastHitStatusMETA { + XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_META = 1, + XR_ENVIRONMENT_RAYCAST_HIT_STATUS_NO_HIT_META = 2, + XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_POINT_OCCLUDED_META = 3, + XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_POINT_OUTSIDE_OF_FOV_META = 4, + XR_ENVIRONMENT_RAYCAST_HIT_STATUS_RAY_OCCLUDED_META = 5, + XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_INVALID_ORIENTATION_META = 6, + XR_ENVIRONMENT_RAYCAST_HIT_STATUS_MAX_ENUM_META = 0x7FFFFFFF +} XrEnvironmentRaycastHitStatusMETA; +// XrSystemEnvironmentRaycastPropertiesMETA extends XrSystemProperties +typedef struct XrSystemEnvironmentRaycastPropertiesMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsEnvironmentRaycast; +} XrSystemEnvironmentRaycastPropertiesMETA; + +typedef struct XrEnvironmentRaycasterCreateInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrEnvironmentRaycasterCreateInfoMETA; + +typedef struct XrEnvironmentRaycasterCreateCompletionMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrResult futureResult; + XrEnvironmentRaycasterMETA environmentRaycaster; +} XrEnvironmentRaycasterCreateCompletionMETA; + +typedef struct XR_MAY_ALIAS XrEnvironmentRaycastFilterBaseHeaderMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrEnvironmentRaycastFilterBaseHeaderMETA; + +typedef struct XrEnvironmentRaycastHitGetInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace baseSpace; + XrTime time; + XrVector3f origin; + XrVector3f direction; + uint32_t filterCount; + const XrEnvironmentRaycastFilterBaseHeaderMETA* const * filters; +} XrEnvironmentRaycastHitGetInfoMETA; + +typedef struct XrEnvironmentRaycastHitMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrEnvironmentRaycastHitStatusMETA status; + XrPosef pose; +} XrEnvironmentRaycastHitMETA; + +typedef struct XrEnvironmentRaycastFilterDistanceMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + float maxDistance; +} XrEnvironmentRaycastFilterDistanceMETA; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateEnvironmentRaycasterAsyncMETA)(XrSession session, const XrEnvironmentRaycasterCreateInfoMETA* info, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrCreateEnvironmentRaycasterCompleteMETA)(XrSession session, XrFutureEXT future, XrEnvironmentRaycasterCreateCompletionMETA* completion); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyEnvironmentRaycasterMETA)(XrEnvironmentRaycasterMETA environmentRaycaster); +typedef XrResult (XRAPI_PTR *PFN_xrPerformEnvironmentRaycastMETA)(XrEnvironmentRaycasterMETA environmentRaycaster, const XrEnvironmentRaycastHitGetInfoMETA* info, XrEnvironmentRaycastHitMETA* hitPoint); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateEnvironmentRaycasterAsyncMETA( + XrSession session, + const XrEnvironmentRaycasterCreateInfoMETA* info, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateEnvironmentRaycasterCompleteMETA( + XrSession session, + XrFutureEXT future, + XrEnvironmentRaycasterCreateCompletionMETA* completion); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyEnvironmentRaycasterMETA( + XrEnvironmentRaycasterMETA environmentRaycaster); + +XRAPI_ATTR XrResult XRAPI_CALL xrPerformEnvironmentRaycastMETA( + XrEnvironmentRaycasterMETA environmentRaycaster, + const XrEnvironmentRaycastHitGetInfoMETA* info, + XrEnvironmentRaycastHitMETA* hitPoint); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_META_tile_properties_hint is a preprocessor guard. Do not pass it to API calls. +#define XR_META_tile_properties_hint 1 +#define XR_META_tile_properties_hint_SPEC_VERSION 1 +#define XR_META_TILE_PROPERTIES_HINT_EXTENSION_NAME "XR_META_tile_properties_hint" +typedef struct XrExtent3DiMETA { + int32_t width; + int32_t height; + int32_t depth; +} XrExtent3DiMETA; + +typedef struct XrTilePropertiesMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrExtent3DiMETA tileDimensions; + XrExtent2Di apronDimensions; + XrOffset2Di origin; +} XrTilePropertiesMETA; + +typedef struct XrTilePropertiesHintMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t propertiesCount; + const XrTilePropertiesMETA* properties; +} XrTilePropertiesHintMETA; + +typedef XrResult (XRAPI_PTR *PFN_xrSetTilePropertiesHintMETA)(XrSession session, const XrTilePropertiesHintMETA* properties); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrSetTilePropertiesHintMETA( + XrSession session, + const XrTilePropertiesHintMETA* properties); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_META_hand_tracking_unextrapolated_poses is a preprocessor guard. Do not pass it to API calls. +#define XR_META_hand_tracking_unextrapolated_poses 1 +#define XR_META_hand_tracking_unextrapolated_poses_SPEC_VERSION 1 +#define XR_META_HAND_TRACKING_UNEXTRAPOLATED_POSES_EXTENSION_NAME "XR_META_hand_tracking_unextrapolated_poses" +// XrHandTrackingUnextrapolatedPosesRequestMETA extends XrHandJointsLocateInfoEXT +typedef struct XrHandTrackingUnextrapolatedPosesRequestMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrHandTrackingUnextrapolatedPosesRequestMETA; + +// XrHandTrackingUnextrapolatedPosesMETA extends XrHandJointLocationsEXT +typedef struct XrHandTrackingUnextrapolatedPosesMETA { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrTime captureTime; +} XrHandTrackingUnextrapolatedPosesMETA; + + + +// XR_META_hand_tracking_frequency_hint is a preprocessor guard. Do not pass it to API calls. +#define XR_META_hand_tracking_frequency_hint 1 +#define XR_META_hand_tracking_frequency_hint_SPEC_VERSION 1 +#define XR_META_HAND_TRACKING_FREQUENCY_HINT_EXTENSION_NAME "XR_META_hand_tracking_frequency_hint" + +typedef enum XrHandTrackingFrequencyHintMETA { + XR_HAND_TRACKING_FREQUENCY_HINT_DEFAULT_META = 1, + XR_HAND_TRACKING_FREQUENCY_HINT_HIGH_META = 2, + XR_HAND_TRACKING_FREQUENCY_HINT_MAX_ENUM_META = 0x7FFFFFFF +} XrHandTrackingFrequencyHintMETA; +typedef XrResult (XRAPI_PTR *PFN_xrSetHandTrackingFrequencyHintMETA)(XrSession session, XrHandTrackingFrequencyHintMETA frequencyHint); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrSetHandTrackingFrequencyHintMETA( + XrSession session, + XrHandTrackingFrequencyHintMETA frequencyHint); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_META_hand_tracking_wide_motion_mode2 is a preprocessor guard. Do not pass it to API calls. +#define XR_META_hand_tracking_wide_motion_mode2 1 +#define XR_META_hand_tracking_wide_motion_mode2_SPEC_VERSION 1 +#define XR_META_HAND_TRACKING_WIDE_MOTION_MODE2_EXTENSION_NAME "XR_META_hand_tracking_wide_motion_mode2" + + +// XR_ANDROID_light_estimation is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_light_estimation 1 +XR_DEFINE_HANDLE(XrLightEstimatorANDROID) +#define XR_ANDROID_light_estimation_SPEC_VERSION 1 +#define XR_ANDROID_LIGHT_ESTIMATION_EXTENSION_NAME "XR_ANDROID_light_estimation" + +typedef enum XrLightEstimateStateANDROID { + XR_LIGHT_ESTIMATE_STATE_VALID_ANDROID = 0, + XR_LIGHT_ESTIMATE_STATE_INVALID_ANDROID = 1, + XR_LIGHT_ESTIMATE_STATE_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrLightEstimateStateANDROID; + +typedef enum XrSphericalHarmonicsKindANDROID { + XR_SPHERICAL_HARMONICS_KIND_TOTAL_ANDROID = 0, + XR_SPHERICAL_HARMONICS_KIND_AMBIENT_ANDROID = 1, + XR_SPHERICAL_HARMONICS_KIND_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrSphericalHarmonicsKindANDROID; +// XrSystemLightEstimationPropertiesANDROID extends XrSystemProperties +typedef struct XrSystemLightEstimationPropertiesANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsLightEstimation; +} XrSystemLightEstimationPropertiesANDROID; + +typedef struct XrLightEstimatorCreateInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrLightEstimatorCreateInfoANDROID; + +typedef struct XrLightEstimateGetInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace space; + XrTime time; +} XrLightEstimateGetInfoANDROID; + +typedef struct XrLightEstimateANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrLightEstimateStateANDROID state; + XrTime lastUpdatedTime; +} XrLightEstimateANDROID; + +// XrDirectionalLightANDROID extends XrLightEstimateANDROID +typedef struct XrDirectionalLightANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrLightEstimateStateANDROID state; + XrVector3f intensity; + XrVector3f direction; +} XrDirectionalLightANDROID; + +// XrAmbientLightANDROID extends XrLightEstimateANDROID +typedef struct XrAmbientLightANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrLightEstimateStateANDROID state; + XrVector3f intensity; + XrVector3f colorCorrection; +} XrAmbientLightANDROID; + +// XrSphericalHarmonicsANDROID extends XrLightEstimateANDROID +typedef struct XrSphericalHarmonicsANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrLightEstimateStateANDROID state; + XrSphericalHarmonicsKindANDROID kind; + float coefficients[9][3]; +} XrSphericalHarmonicsANDROID; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateLightEstimatorANDROID)(XrSession session, XrLightEstimatorCreateInfoANDROID* createInfo, XrLightEstimatorANDROID* outHandle); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyLightEstimatorANDROID)(XrLightEstimatorANDROID estimator); +typedef XrResult (XRAPI_PTR *PFN_xrGetLightEstimateANDROID)(XrLightEstimatorANDROID estimator, const XrLightEstimateGetInfoANDROID* input, XrLightEstimateANDROID* output); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateLightEstimatorANDROID( + XrSession session, + XrLightEstimatorCreateInfoANDROID* createInfo, + XrLightEstimatorANDROID* outHandle); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyLightEstimatorANDROID( + XrLightEstimatorANDROID estimator); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetLightEstimateANDROID( + XrLightEstimatorANDROID estimator, + const XrLightEstimateGetInfoANDROID* input, + XrLightEstimateANDROID* output); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ANDROID_mouse_interaction is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_mouse_interaction 1 +#define XR_ANDROID_mouse_interaction_SPEC_VERSION 1 +#define XR_ANDROID_MOUSE_INTERACTION_EXTENSION_NAME "XR_ANDROID_mouse_interaction" + + +// XR_ANDROID_trackables_marker is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_trackables_marker 1 +#define XR_ANDROID_trackables_marker_SPEC_VERSION 1 +#define XR_ANDROID_TRACKABLES_MARKER_EXTENSION_NAME "XR_ANDROID_trackables_marker" + +typedef enum XrTrackableMarkerTrackingModeANDROID { + XR_TRACKABLE_MARKER_TRACKING_MODE_DYNAMIC_ANDROID = 0, + XR_TRACKABLE_MARKER_TRACKING_MODE_STATIC_ANDROID = 1, + XR_TRACKABLE_MARKER_TRACKING_MODE_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrTrackableMarkerTrackingModeANDROID; + +typedef enum XrTrackableMarkerDictionaryANDROID { + XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_50_ANDROID = 0, + XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_100_ANDROID = 1, + XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_250_ANDROID = 2, + XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_1000_ANDROID = 3, + XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_50_ANDROID = 4, + XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_100_ANDROID = 5, + XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_250_ANDROID = 6, + XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_1000_ANDROID = 7, + XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_50_ANDROID = 8, + XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_100_ANDROID = 9, + XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_250_ANDROID = 10, + XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_1000_ANDROID = 11, + XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_50_ANDROID = 12, + XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_100_ANDROID = 13, + XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_250_ANDROID = 14, + XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_1000_ANDROID = 15, + XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_16H5_ANDROID = 16, + XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_25H9_ANDROID = 17, + XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_36H10_ANDROID = 18, + XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_36H11_ANDROID = 19, + XR_TRACKABLE_MARKER_DICTIONARY_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrTrackableMarkerDictionaryANDROID; +// XrSystemMarkerTrackingPropertiesANDROID extends XrSystemProperties +typedef struct XrSystemMarkerTrackingPropertiesANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsMarkerTracking; + XrBool32 supportsMarkerSizeEstimation; + uint16_t maxMarkerCount; +} XrSystemMarkerTrackingPropertiesANDROID; + +typedef struct XrTrackableMarkerDatabaseEntryANDROID { + int32_t id; + float edgeSize; +} XrTrackableMarkerDatabaseEntryANDROID; + +typedef struct XrTrackableMarkerDatabaseANDROID { + XrTrackableMarkerDictionaryANDROID dictionary; + uint32_t entryCount; + const XrTrackableMarkerDatabaseEntryANDROID* entries; +} XrTrackableMarkerDatabaseANDROID; + +// XrTrackableMarkerConfigurationANDROID extends XrTrackableTrackerCreateInfoANDROID +typedef struct XrTrackableMarkerConfigurationANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrTrackableMarkerTrackingModeANDROID trackingMode; + uint32_t databaseCount; + const XrTrackableMarkerDatabaseANDROID* databases; +} XrTrackableMarkerConfigurationANDROID; + +typedef struct XrTrackableMarkerANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrTrackingStateANDROID trackingState; + XrTime lastUpdatedTime; + XrTrackableMarkerDictionaryANDROID dictionary; + int32_t markerId; + XrPosef centerPose; + XrExtent2Df extents; +} XrTrackableMarkerANDROID; + +typedef XrResult (XRAPI_PTR *PFN_xrGetTrackableMarkerANDROID)(XrTrackableTrackerANDROID tracker, const XrTrackableGetInfoANDROID* getInfo, XrTrackableMarkerANDROID* markerOutput); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetTrackableMarkerANDROID( + XrTrackableTrackerANDROID tracker, + const XrTrackableGetInfoANDROID* getInfo, + XrTrackableMarkerANDROID* markerOutput); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ANDROID_trackables_qr_code is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_trackables_qr_code 1 +#define XR_ANDROID_trackables_qr_code_SPEC_VERSION 1 +#define XR_ANDROID_TRACKABLES_QR_CODE_EXTENSION_NAME "XR_ANDROID_trackables_qr_code" + +typedef enum XrQrCodeTrackingModeANDROID { + XR_QR_CODE_TRACKING_MODE_DYNAMIC_ANDROID = 0, + XR_QR_CODE_TRACKING_MODE_STATIC_ANDROID = 1, + XR_QR_CODE_TRACKING_MODE_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrQrCodeTrackingModeANDROID; +// XrSystemQrCodeTrackingPropertiesANDROID extends XrSystemProperties +typedef struct XrSystemQrCodeTrackingPropertiesANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsQrCodeTracking; + XrBool32 supportsQrCodeSizeEstimation; + uint16_t maxQrCodeCount; +} XrSystemQrCodeTrackingPropertiesANDROID; + +// XrTrackableQrCodeConfigurationANDROID extends XrTrackableTrackerCreateInfoANDROID +typedef struct XrTrackableQrCodeConfigurationANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrQrCodeTrackingModeANDROID trackingMode; + float qrCodeEdgeSize; +} XrTrackableQrCodeConfigurationANDROID; + +typedef struct XrTrackableQrCodeANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrTrackingStateANDROID trackingState; + XrTime lastUpdatedTime; + XrPosef centerPose; + XrExtent2Df extents; + uint32_t bufferCapacityInput; + uint32_t bufferCountOutput; + char* buffer; +} XrTrackableQrCodeANDROID; + +typedef XrResult (XRAPI_PTR *PFN_xrGetTrackableQrCodeANDROID)(XrTrackableTrackerANDROID tracker, const XrTrackableGetInfoANDROID* getInfo, XrTrackableQrCodeANDROID* qrCodeOutput); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetTrackableQrCodeANDROID( + XrTrackableTrackerANDROID tracker, + const XrTrackableGetInfoANDROID* getInfo, + XrTrackableQrCodeANDROID* qrCodeOutput); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ANDROID_trackables_image is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_trackables_image 1 +XR_DEFINE_HANDLE(XrTrackableImageDatabaseANDROID) +#define XR_ANDROID_trackables_image_SPEC_VERSION 1 +#define XR_ANDROID_TRACKABLES_IMAGE_EXTENSION_NAME "XR_ANDROID_trackables_image" + +typedef enum XrTrackableImageTrackingModeANDROID { + XR_TRACKABLE_IMAGE_TRACKING_MODE_DYNAMIC_ANDROID = 1, + XR_TRACKABLE_IMAGE_TRACKING_MODE_STATIC_ANDROID = 2, + XR_TRACKABLE_IMAGE_TRACKING_MODE_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrTrackableImageTrackingModeANDROID; + +typedef enum XrTrackableImageFormatANDROID { + XR_TRACKABLE_IMAGE_FORMAT_R8G8B8A8_ANDROID = 1, + XR_TRACKABLE_IMAGE_FORMAT_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrTrackableImageFormatANDROID; +// XrSystemImageTrackingPropertiesANDROID extends XrSystemProperties +typedef struct XrSystemImageTrackingPropertiesANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsImageTracking; + XrBool32 supportsPhysicalSizeEstimation; + uint32_t maxTrackedImageCount; + uint32_t maxLoadedImageCount; +} XrSystemImageTrackingPropertiesANDROID; + +typedef struct XrTrackableImageDatabaseEntryANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrTrackableImageTrackingModeANDROID trackingMode; + float physicalWidth; + uint32_t imageWidth; + uint32_t imageHeight; + XrTrackableImageFormatANDROID format; + uint32_t bufferSize; + const uint8_t* buffer; +} XrTrackableImageDatabaseEntryANDROID; + +typedef struct XrTrackableImageDatabaseCreateInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t entryCount; + const XrTrackableImageDatabaseEntryANDROID* entries; +} XrTrackableImageDatabaseCreateInfoANDROID; + +typedef struct XrCreateTrackableImageDatabaseCompletionANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrResult futureResult; + XrTrackableImageDatabaseANDROID database; +} XrCreateTrackableImageDatabaseCompletionANDROID; + +typedef struct XrTrackableImageConfigurationANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t databaseCount; + const XrTrackableImageDatabaseANDROID* databases; +} XrTrackableImageConfigurationANDROID; + +typedef struct XrTrackableImageANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrTrackingStateANDROID trackingState; + XrTime lastUpdatedTime; + XrTrackableImageDatabaseANDROID database; + uint32_t databaseEntryIndex; + XrPosef centerPose; + XrExtent2Df extents; +} XrTrackableImageANDROID; + +typedef struct XrEventDataImageTrackingLostANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrTime time; +} XrEventDataImageTrackingLostANDROID; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateTrackableImageDatabaseAsyncANDROID)(XrSession session, const XrTrackableImageDatabaseCreateInfoANDROID* createInfo, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrCreateTrackableImageDatabaseCompleteANDROID)(XrSession session, XrFutureEXT future, XrCreateTrackableImageDatabaseCompletionANDROID* completion); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyTrackableImageDatabaseANDROID)(XrTrackableImageDatabaseANDROID database); +typedef XrResult (XRAPI_PTR *PFN_xrAddTrackableImageDatabaseANDROID)(XrTrackableTrackerANDROID tracker, XrTrackableImageDatabaseANDROID database); +typedef XrResult (XRAPI_PTR *PFN_xrRemoveTrackableImageDatabaseANDROID)(XrTrackableTrackerANDROID tracker, XrTrackableImageDatabaseANDROID database); +typedef XrResult (XRAPI_PTR *PFN_xrGetTrackableImageANDROID)(XrTrackableTrackerANDROID tracker, const XrTrackableGetInfoANDROID* getInfo, XrTrackableImageANDROID* trackable); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateTrackableImageDatabaseAsyncANDROID( + XrSession session, + const XrTrackableImageDatabaseCreateInfoANDROID* createInfo, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateTrackableImageDatabaseCompleteANDROID( + XrSession session, + XrFutureEXT future, + XrCreateTrackableImageDatabaseCompletionANDROID* completion); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyTrackableImageDatabaseANDROID( + XrTrackableImageDatabaseANDROID database); + +XRAPI_ATTR XrResult XRAPI_CALL xrAddTrackableImageDatabaseANDROID( + XrTrackableTrackerANDROID tracker, + XrTrackableImageDatabaseANDROID database); + +XRAPI_ATTR XrResult XRAPI_CALL xrRemoveTrackableImageDatabaseANDROID( + XrTrackableTrackerANDROID tracker, + XrTrackableImageDatabaseANDROID database); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetTrackableImageANDROID( + XrTrackableTrackerANDROID tracker, + const XrTrackableGetInfoANDROID* getInfo, + XrTrackableImageANDROID* trackable); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ANDROID_scene_meshing is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_scene_meshing 1 +XR_DEFINE_HANDLE(XrSceneMeshingTrackerANDROID) +XR_DEFINE_HANDLE(XrSceneMeshSnapshotANDROID) +#define XR_ANDROID_scene_meshing_SPEC_VERSION 3 +#define XR_ANDROID_SCENE_MESHING_EXTENSION_NAME "XR_ANDROID_scene_meshing" + +typedef enum XrSceneMeshSemanticLabelSetANDROID { + XR_SCENE_MESH_SEMANTIC_LABEL_SET_NONE_ANDROID = 0, + XR_SCENE_MESH_SEMANTIC_LABEL_SET_DEFAULT_ANDROID = 1, + XR_SCENE_MESH_SEMANTIC_LABEL_SET_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrSceneMeshSemanticLabelSetANDROID; + +typedef enum XrSceneMeshTrackingStateANDROID { + XR_SCENE_MESH_TRACKING_STATE_INITIALIZING_ANDROID = 0, + XR_SCENE_MESH_TRACKING_STATE_TRACKING_ANDROID = 1, + XR_SCENE_MESH_TRACKING_STATE_WAITING_ANDROID = 2, + XR_SCENE_MESH_TRACKING_STATE_ERROR_ANDROID = 3, + XR_SCENE_MESH_TRACKING_STATE_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrSceneMeshTrackingStateANDROID; + +typedef enum XrSceneMeshSemanticLabelANDROID { + XR_SCENE_MESH_SEMANTIC_LABEL_OTHER_ANDROID = 0, + XR_SCENE_MESH_SEMANTIC_LABEL_FLOOR_ANDROID = 1, + XR_SCENE_MESH_SEMANTIC_LABEL_CEILING_ANDROID = 2, + XR_SCENE_MESH_SEMANTIC_LABEL_WALL_ANDROID = 3, + XR_SCENE_MESH_SEMANTIC_LABEL_TABLE_ANDROID = 4, + XR_SCENE_MESH_SEMANTIC_LABEL_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrSceneMeshSemanticLabelANDROID; +// XrSystemSceneMeshingPropertiesANDROID extends XrSystemProperties +typedef struct XrSystemSceneMeshingPropertiesANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsSceneMeshing; +} XrSystemSceneMeshingPropertiesANDROID; + +typedef struct XrSceneMeshingTrackerCreateInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSceneMeshSemanticLabelSetANDROID semanticLabelSet; + XrBool32 enableNormals; +} XrSceneMeshingTrackerCreateInfoANDROID; + +typedef struct XrSceneMeshSnapshotCreateInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace baseSpace; + XrTime time; + XrBoxf boundingBox; +} XrSceneMeshSnapshotCreateInfoANDROID; + +typedef struct XrSceneMeshSnapshotCreationResultANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSceneMeshSnapshotANDROID snapshot; + XrSceneMeshTrackingStateANDROID trackingState; +} XrSceneMeshSnapshotCreationResultANDROID; + +typedef struct XrSceneSubmeshStateANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrUuid submeshId; + XrTime lastUpdatedTime; + XrPosef submeshPoseInBaseSpace; + XrExtent3Df bounds; +} XrSceneSubmeshStateANDROID; + +typedef struct XrSceneSubmeshDataANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrUuid submeshId; + uint32_t vertexCapacityInput; + uint32_t vertexCountOutput; + XrVector3f* vertexPositions; + XrVector3f* vertexNormals; + uint8_t* vertexSemantics; + uint32_t indexCapacityInput; + uint32_t indexCountOutput; + uint32_t* indices; +} XrSceneSubmeshDataANDROID; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSupportedSemanticLabelSetsANDROID)(XrInstance instance, XrSystemId systemId, uint32_t supportedSemanticLabelSetsInputCapacity, uint32_t* supportedSemanticLabelSetsOutputCount, XrSceneMeshSemanticLabelSetANDROID* supportedSemanticLabelSets); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSceneMeshingTrackerANDROID)(XrSession session, const XrSceneMeshingTrackerCreateInfoANDROID* createInfo, XrSceneMeshingTrackerANDROID* tracker); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySceneMeshingTrackerANDROID)(XrSceneMeshingTrackerANDROID tracker); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSceneMeshSnapshotANDROID)(XrSceneMeshingTrackerANDROID tracker, const XrSceneMeshSnapshotCreateInfoANDROID* createInfo, XrSceneMeshSnapshotCreationResultANDROID* outSnapshotCreationResult); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySceneMeshSnapshotANDROID)(XrSceneMeshSnapshotANDROID snapshot); +typedef XrResult (XRAPI_PTR *PFN_xrGetAllSubmeshStatesANDROID)(XrSceneMeshSnapshotANDROID snapshot, uint32_t submeshStateCapacityInput, uint32_t* submeshStateCountOutput, XrSceneSubmeshStateANDROID* submeshStates); +typedef XrResult (XRAPI_PTR *PFN_xrGetSubmeshDataANDROID)(XrSceneMeshSnapshotANDROID snapshot, uint32_t submeshDataCount, XrSceneSubmeshDataANDROID* inoutSubmeshData); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSupportedSemanticLabelSetsANDROID( + XrInstance instance, + XrSystemId systemId, + uint32_t supportedSemanticLabelSetsInputCapacity, + uint32_t* supportedSemanticLabelSetsOutputCount, + XrSceneMeshSemanticLabelSetANDROID* supportedSemanticLabelSets); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSceneMeshingTrackerANDROID( + XrSession session, + const XrSceneMeshingTrackerCreateInfoANDROID* createInfo, + XrSceneMeshingTrackerANDROID* tracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySceneMeshingTrackerANDROID( + XrSceneMeshingTrackerANDROID tracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSceneMeshSnapshotANDROID( + XrSceneMeshingTrackerANDROID tracker, + const XrSceneMeshSnapshotCreateInfoANDROID* createInfo, + XrSceneMeshSnapshotCreationResultANDROID* outSnapshotCreationResult); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySceneMeshSnapshotANDROID( + XrSceneMeshSnapshotANDROID snapshot); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetAllSubmeshStatesANDROID( + XrSceneMeshSnapshotANDROID snapshot, + uint32_t submeshStateCapacityInput, + uint32_t* submeshStateCountOutput, + XrSceneSubmeshStateANDROID* submeshStates); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSubmeshDataANDROID( + XrSceneMeshSnapshotANDROID snapshot, + uint32_t submeshDataCount, + XrSceneSubmeshDataANDROID* inoutSubmeshData); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_EXT_spatial_entity is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_spatial_entity 1 + +#define XR_NULL_SPATIAL_ENTITY_ID_EXT 0 + + +#define XR_NULL_SPATIAL_BUFFER_ID_EXT 0 + +XR_DEFINE_ATOM(XrSpatialEntityIdEXT) +XR_DEFINE_ATOM(XrSpatialBufferIdEXT) +XR_DEFINE_HANDLE(XrSpatialEntityEXT) +XR_DEFINE_HANDLE(XrSpatialContextEXT) +XR_DEFINE_HANDLE(XrSpatialSnapshotEXT) +#define XR_EXT_spatial_entity_SPEC_VERSION 1 +#define XR_EXT_SPATIAL_ENTITY_EXTENSION_NAME "XR_EXT_spatial_entity" + +typedef enum XrSpatialCapabilityEXT { + XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT = 1000741000, + XR_SPATIAL_CAPABILITY_MARKER_TRACKING_QR_CODE_EXT = 1000743000, + XR_SPATIAL_CAPABILITY_MARKER_TRACKING_MICRO_QR_CODE_EXT = 1000743001, + XR_SPATIAL_CAPABILITY_MARKER_TRACKING_ARUCO_MARKER_EXT = 1000743002, + XR_SPATIAL_CAPABILITY_MARKER_TRACKING_APRIL_TAG_EXT = 1000743003, + XR_SPATIAL_CAPABILITY_ANCHOR_EXT = 1000762000, + XR_SPATIAL_CAPABILITY_IMAGE_TRACKING_EXT = 1000782000, + XR_SPATIAL_CAPABILITY_OBJECT_TRACKING_ANDROID = 1000785000, + XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID = 1000786000, + XR_SPATIAL_CAPABILITY_MAX_ENUM_EXT = 0x7FFFFFFF +} XrSpatialCapabilityEXT; + +typedef enum XrSpatialCapabilityFeatureEXT { + XR_SPATIAL_CAPABILITY_FEATURE_MARKER_TRACKING_FIXED_SIZE_MARKERS_EXT = 1000743000, + XR_SPATIAL_CAPABILITY_FEATURE_MARKER_TRACKING_STATIC_MARKERS_EXT = 1000743001, + XR_SPATIAL_CAPABILITY_FEATURE_SPHERE_BOUNDS_FILTER_ANDROID = 1000761000, + XR_SPATIAL_CAPABILITY_FEATURE_BOX_BOUNDS_FILTER_ANDROID = 1000761001, + XR_SPATIAL_CAPABILITY_FEATURE_FRUSTUM_BOUNDS_FILTER_ANDROID = 1000761002, + XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_AUTOMATIC_SIZE_IMAGES_EXT = 1000782000, + XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_STATIC_IMAGES_EXT = 1000782001, + XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_FIXED_SIZE_IMAGES_EXT = 1000782002, + XR_SPATIAL_CAPABILITY_FEATURE_MAX_ENUM_EXT = 0x7FFFFFFF +} XrSpatialCapabilityFeatureEXT; + +typedef enum XrSpatialComponentTypeEXT { + XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT = 1, + XR_SPATIAL_COMPONENT_TYPE_BOUNDED_3D_EXT = 2, + XR_SPATIAL_COMPONENT_TYPE_PARENT_EXT = 3, + XR_SPATIAL_COMPONENT_TYPE_MESH_3D_EXT = 4, + XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT = 1000741000, + XR_SPATIAL_COMPONENT_TYPE_MESH_2D_EXT = 1000741001, + XR_SPATIAL_COMPONENT_TYPE_POLYGON_2D_EXT = 1000741002, + XR_SPATIAL_COMPONENT_TYPE_PLANE_SEMANTIC_LABEL_EXT = 1000741003, + XR_SPATIAL_COMPONENT_TYPE_MARKER_EXT = 1000743000, + XR_SPATIAL_COMPONENT_TYPE_ANCHOR_EXT = 1000762000, + XR_SPATIAL_COMPONENT_TYPE_PERSISTENCE_EXT = 1000763000, + XR_SPATIAL_COMPONENT_TYPE_IMAGE_2D_EXT = 1000782000, + XR_SPATIAL_COMPONENT_TYPE_OBJECT_SEMANTIC_LABEL_ANDROID = 1000785000, + XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID = 1000786000, + XR_SPATIAL_COMPONENT_TYPE_SUBSUMED_BY_ANDROID = 1000791000, + XR_SPATIAL_COMPONENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} XrSpatialComponentTypeEXT; + +typedef enum XrSpatialEntityTrackingStateEXT { + XR_SPATIAL_ENTITY_TRACKING_STATE_STOPPED_EXT = 1, + XR_SPATIAL_ENTITY_TRACKING_STATE_PAUSED_EXT = 2, + XR_SPATIAL_ENTITY_TRACKING_STATE_TRACKING_EXT = 3, + XR_SPATIAL_ENTITY_TRACKING_STATE_MAX_ENUM_EXT = 0x7FFFFFFF +} XrSpatialEntityTrackingStateEXT; + +typedef enum XrSpatialBufferTypeEXT { + XR_SPATIAL_BUFFER_TYPE_UNKNOWN_EXT = 0, + XR_SPATIAL_BUFFER_TYPE_STRING_EXT = 1, + XR_SPATIAL_BUFFER_TYPE_UINT8_EXT = 2, + XR_SPATIAL_BUFFER_TYPE_UINT16_EXT = 3, + XR_SPATIAL_BUFFER_TYPE_UINT32_EXT = 4, + XR_SPATIAL_BUFFER_TYPE_FLOAT_EXT = 5, + XR_SPATIAL_BUFFER_TYPE_VECTOR2F_EXT = 6, + XR_SPATIAL_BUFFER_TYPE_VECTOR3F_EXT = 7, + XR_SPATIAL_BUFFER_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} XrSpatialBufferTypeEXT; +typedef struct XrSpatialCapabilityComponentTypesEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t componentTypeCapacityInput; + uint32_t componentTypeCountOutput; + XrSpatialComponentTypeEXT* componentTypes; +} XrSpatialCapabilityComponentTypesEXT; + +typedef struct XR_MAY_ALIAS XrSpatialCapabilityConfigurationBaseHeaderEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialCapabilityEXT capability; + uint32_t enabledComponentCount; + const XrSpatialComponentTypeEXT* enabledComponents; +} XrSpatialCapabilityConfigurationBaseHeaderEXT; + +typedef struct XrSpatialContextCreateInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t capabilityConfigCount; + const XrSpatialCapabilityConfigurationBaseHeaderEXT* const* capabilityConfigs; +} XrSpatialContextCreateInfoEXT; + +typedef struct XrCreateSpatialContextCompletionEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrResult futureResult; + XrSpatialContextEXT spatialContext; +} XrCreateSpatialContextCompletionEXT; + +typedef struct XrSpatialDiscoverySnapshotCreateInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t componentTypeCount; + const XrSpatialComponentTypeEXT* componentTypes; +} XrSpatialDiscoverySnapshotCreateInfoEXT; + +typedef struct XrCreateSpatialDiscoverySnapshotCompletionInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace baseSpace; + XrTime time; + XrFutureEXT future; +} XrCreateSpatialDiscoverySnapshotCompletionInfoEXT; + +typedef struct XrCreateSpatialDiscoverySnapshotCompletionEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrResult futureResult; + XrSpatialSnapshotEXT snapshot; +} XrCreateSpatialDiscoverySnapshotCompletionEXT; + +typedef struct XrSpatialComponentDataQueryConditionEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t componentTypeCount; + const XrSpatialComponentTypeEXT* componentTypes; +} XrSpatialComponentDataQueryConditionEXT; + +typedef struct XrSpatialComponentDataQueryResultEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t entityIdCapacityInput; + uint32_t entityIdCountOutput; + XrSpatialEntityIdEXT* entityIds; + uint32_t entityStateCapacityInput; + uint32_t entityStateCountOutput; + XrSpatialEntityTrackingStateEXT* entityStates; +} XrSpatialComponentDataQueryResultEXT; + +typedef struct XrSpatialBufferEXT { + XrSpatialBufferIdEXT bufferId; + XrSpatialBufferTypeEXT bufferType; +} XrSpatialBufferEXT; + +typedef struct XrSpatialBufferGetInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialBufferIdEXT bufferId; +} XrSpatialBufferGetInfoEXT; + +typedef struct XrSpatialBounded2DDataEXT { + XrPosef center; + XrExtent2Df extents; +} XrSpatialBounded2DDataEXT; + +// XrSpatialComponentBounded2DListEXT extends XrSpatialComponentDataQueryResultEXT +typedef struct XrSpatialComponentBounded2DListEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t boundCount; + XrSpatialBounded2DDataEXT* bounds; +} XrSpatialComponentBounded2DListEXT; + +// XrSpatialComponentBounded3DListEXT extends XrSpatialComponentDataQueryResultEXT +typedef struct XrSpatialComponentBounded3DListEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t boundCount; + XrBoxf* bounds; +} XrSpatialComponentBounded3DListEXT; + +// XrSpatialComponentParentListEXT extends XrSpatialComponentDataQueryResultEXT +typedef struct XrSpatialComponentParentListEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t parentCount; + XrSpatialEntityIdEXT* parents; +} XrSpatialComponentParentListEXT; + +typedef struct XrSpatialMeshDataEXT { + XrPosef origin; + XrSpatialBufferEXT vertexBuffer; + XrSpatialBufferEXT indexBuffer; +} XrSpatialMeshDataEXT; + +// XrSpatialComponentMesh3DListEXT extends XrSpatialComponentDataQueryResultEXT +typedef struct XrSpatialComponentMesh3DListEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t meshCount; + XrSpatialMeshDataEXT* meshes; +} XrSpatialComponentMesh3DListEXT; + +typedef struct XrSpatialEntityFromIdCreateInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialEntityIdEXT entityId; +} XrSpatialEntityFromIdCreateInfoEXT; + +typedef struct XrSpatialUpdateSnapshotCreateInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t entityCount; + const XrSpatialEntityEXT* entities; + uint32_t componentTypeCount; + const XrSpatialComponentTypeEXT* componentTypes; + XrSpace baseSpace; + XrTime time; +} XrSpatialUpdateSnapshotCreateInfoEXT; + +typedef struct XrEventDataSpatialDiscoveryRecommendedEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialContextEXT spatialContext; +} XrEventDataSpatialDiscoveryRecommendedEXT; + +// XrSpatialFilterTrackingStateEXT extends XrSpatialDiscoverySnapshotCreateInfoEXT,XrSpatialComponentDataQueryConditionEXT +typedef struct XrSpatialFilterTrackingStateEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialEntityTrackingStateEXT trackingState; +} XrSpatialFilterTrackingStateEXT; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSpatialCapabilitiesEXT)(XrInstance instance, XrSystemId systemId, uint32_t capabilityCapacityInput, uint32_t* capabilityCountOutput, XrSpatialCapabilityEXT* capabilities); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSpatialCapabilityComponentTypesEXT)(XrInstance instance, XrSystemId systemId, XrSpatialCapabilityEXT capability, XrSpatialCapabilityComponentTypesEXT* capabilityComponents); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSpatialCapabilityFeaturesEXT)(XrInstance instance, XrSystemId systemId, XrSpatialCapabilityEXT capability, uint32_t capabilityFeatureCapacityInput, uint32_t* capabilityFeatureCountOutput, XrSpatialCapabilityFeatureEXT* capabilityFeatures); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialContextAsyncEXT)(XrSession session, const XrSpatialContextCreateInfoEXT* createInfo, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialContextCompleteEXT)(XrSession session, XrFutureEXT future, XrCreateSpatialContextCompletionEXT* completion); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialContextEXT)(XrSpatialContextEXT spatialContext); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialDiscoverySnapshotAsyncEXT)(XrSpatialContextEXT spatialContext, const XrSpatialDiscoverySnapshotCreateInfoEXT* createInfo, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialDiscoverySnapshotCompleteEXT)(XrSpatialContextEXT spatialContext, const XrCreateSpatialDiscoverySnapshotCompletionInfoEXT* createSnapshotCompletionInfo, XrCreateSpatialDiscoverySnapshotCompletionEXT* completion); +typedef XrResult (XRAPI_PTR *PFN_xrQuerySpatialComponentDataEXT)(XrSpatialSnapshotEXT snapshot, const XrSpatialComponentDataQueryConditionEXT* queryCondition, XrSpatialComponentDataQueryResultEXT* queryResult); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialSnapshotEXT)(XrSpatialSnapshotEXT snapshot); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialEntityFromIdEXT)(XrSpatialContextEXT spatialContext, const XrSpatialEntityFromIdCreateInfoEXT* createInfo, XrSpatialEntityEXT* spatialEntity); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialEntityEXT)(XrSpatialEntityEXT spatialEntity); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialUpdateSnapshotEXT)(XrSpatialContextEXT spatialContext, const XrSpatialUpdateSnapshotCreateInfoEXT* createInfo, XrSpatialSnapshotEXT* snapshot); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialBufferStringEXT)(XrSpatialSnapshotEXT snapshot, const XrSpatialBufferGetInfoEXT* info, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, char* buffer); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialBufferUint8EXT)(XrSpatialSnapshotEXT snapshot, const XrSpatialBufferGetInfoEXT* info, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, uint8_t* buffer); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialBufferUint16EXT)(XrSpatialSnapshotEXT snapshot, const XrSpatialBufferGetInfoEXT* info, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, uint16_t* buffer); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialBufferUint32EXT)(XrSpatialSnapshotEXT snapshot, const XrSpatialBufferGetInfoEXT* info, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, uint32_t* buffer); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialBufferFloatEXT)(XrSpatialSnapshotEXT snapshot, const XrSpatialBufferGetInfoEXT* info, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, float* buffer); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialBufferVector2fEXT)(XrSpatialSnapshotEXT snapshot, const XrSpatialBufferGetInfoEXT* info, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, XrVector2f* buffer); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialBufferVector3fEXT)(XrSpatialSnapshotEXT snapshot, const XrSpatialBufferGetInfoEXT* info, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, XrVector3f* buffer); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSpatialCapabilitiesEXT( + XrInstance instance, + XrSystemId systemId, + uint32_t capabilityCapacityInput, + uint32_t* capabilityCountOutput, + XrSpatialCapabilityEXT* capabilities); + +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSpatialCapabilityComponentTypesEXT( + XrInstance instance, + XrSystemId systemId, + XrSpatialCapabilityEXT capability, + XrSpatialCapabilityComponentTypesEXT* capabilityComponents); + +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSpatialCapabilityFeaturesEXT( + XrInstance instance, + XrSystemId systemId, + XrSpatialCapabilityEXT capability, + uint32_t capabilityFeatureCapacityInput, + uint32_t* capabilityFeatureCountOutput, + XrSpatialCapabilityFeatureEXT* capabilityFeatures); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialContextAsyncEXT( + XrSession session, + const XrSpatialContextCreateInfoEXT* createInfo, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialContextCompleteEXT( + XrSession session, + XrFutureEXT future, + XrCreateSpatialContextCompletionEXT* completion); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialContextEXT( + XrSpatialContextEXT spatialContext); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialDiscoverySnapshotAsyncEXT( + XrSpatialContextEXT spatialContext, + const XrSpatialDiscoverySnapshotCreateInfoEXT* createInfo, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialDiscoverySnapshotCompleteEXT( + XrSpatialContextEXT spatialContext, + const XrCreateSpatialDiscoverySnapshotCompletionInfoEXT* createSnapshotCompletionInfo, + XrCreateSpatialDiscoverySnapshotCompletionEXT* completion); + +XRAPI_ATTR XrResult XRAPI_CALL xrQuerySpatialComponentDataEXT( + XrSpatialSnapshotEXT snapshot, + const XrSpatialComponentDataQueryConditionEXT* queryCondition, + XrSpatialComponentDataQueryResultEXT* queryResult); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialSnapshotEXT( + XrSpatialSnapshotEXT snapshot); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialEntityFromIdEXT( + XrSpatialContextEXT spatialContext, + const XrSpatialEntityFromIdCreateInfoEXT* createInfo, + XrSpatialEntityEXT* spatialEntity); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialEntityEXT( + XrSpatialEntityEXT spatialEntity); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialUpdateSnapshotEXT( + XrSpatialContextEXT spatialContext, + const XrSpatialUpdateSnapshotCreateInfoEXT* createInfo, + XrSpatialSnapshotEXT* snapshot); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialBufferStringEXT( + XrSpatialSnapshotEXT snapshot, + const XrSpatialBufferGetInfoEXT* info, + uint32_t bufferCapacityInput, + uint32_t* bufferCountOutput, + char* buffer); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialBufferUint8EXT( + XrSpatialSnapshotEXT snapshot, + const XrSpatialBufferGetInfoEXT* info, + uint32_t bufferCapacityInput, + uint32_t* bufferCountOutput, + uint8_t* buffer); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialBufferUint16EXT( + XrSpatialSnapshotEXT snapshot, + const XrSpatialBufferGetInfoEXT* info, + uint32_t bufferCapacityInput, + uint32_t* bufferCountOutput, + uint16_t* buffer); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialBufferUint32EXT( + XrSpatialSnapshotEXT snapshot, + const XrSpatialBufferGetInfoEXT* info, + uint32_t bufferCapacityInput, + uint32_t* bufferCountOutput, + uint32_t* buffer); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialBufferFloatEXT( + XrSpatialSnapshotEXT snapshot, + const XrSpatialBufferGetInfoEXT* info, + uint32_t bufferCapacityInput, + uint32_t* bufferCountOutput, + float* buffer); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialBufferVector2fEXT( + XrSpatialSnapshotEXT snapshot, + const XrSpatialBufferGetInfoEXT* info, + uint32_t bufferCapacityInput, + uint32_t* bufferCountOutput, + XrVector2f* buffer); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialBufferVector3fEXT( + XrSpatialSnapshotEXT snapshot, + const XrSpatialBufferGetInfoEXT* info, + uint32_t bufferCapacityInput, + uint32_t* bufferCountOutput, + XrVector3f* buffer); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_EXT_spatial_plane_tracking is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_spatial_plane_tracking 1 +#define XR_EXT_spatial_plane_tracking_SPEC_VERSION 1 +#define XR_EXT_SPATIAL_PLANE_TRACKING_EXTENSION_NAME "XR_EXT_spatial_plane_tracking" + +typedef enum XrSpatialPlaneAlignmentEXT { + XR_SPATIAL_PLANE_ALIGNMENT_HORIZONTAL_UPWARD_EXT = 0, + XR_SPATIAL_PLANE_ALIGNMENT_HORIZONTAL_DOWNWARD_EXT = 1, + XR_SPATIAL_PLANE_ALIGNMENT_VERTICAL_EXT = 2, + XR_SPATIAL_PLANE_ALIGNMENT_ARBITRARY_EXT = 3, + XR_SPATIAL_PLANE_ALIGNMENT_MAX_ENUM_EXT = 0x7FFFFFFF +} XrSpatialPlaneAlignmentEXT; + +typedef enum XrSpatialPlaneSemanticLabelEXT { + XR_SPATIAL_PLANE_SEMANTIC_LABEL_UNCATEGORIZED_EXT = 1, + XR_SPATIAL_PLANE_SEMANTIC_LABEL_FLOOR_EXT = 2, + XR_SPATIAL_PLANE_SEMANTIC_LABEL_WALL_EXT = 3, + XR_SPATIAL_PLANE_SEMANTIC_LABEL_CEILING_EXT = 4, + XR_SPATIAL_PLANE_SEMANTIC_LABEL_TABLE_EXT = 5, + XR_SPATIAL_PLANE_SEMANTIC_LABEL_MAX_ENUM_EXT = 0x7FFFFFFF +} XrSpatialPlaneSemanticLabelEXT; +typedef struct XrSpatialCapabilityConfigurationPlaneTrackingEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialCapabilityEXT capability; + uint32_t enabledComponentCount; + const XrSpatialComponentTypeEXT* enabledComponents; +} XrSpatialCapabilityConfigurationPlaneTrackingEXT; + +// XrSpatialComponentPlaneAlignmentListEXT extends XrSpatialComponentDataQueryResultEXT +typedef struct XrSpatialComponentPlaneAlignmentListEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t planeAlignmentCount; + XrSpatialPlaneAlignmentEXT* planeAlignments; +} XrSpatialComponentPlaneAlignmentListEXT; + +// XrSpatialComponentMesh2DListEXT extends XrSpatialComponentDataQueryResultEXT +typedef struct XrSpatialComponentMesh2DListEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t meshCount; + XrSpatialMeshDataEXT* meshes; +} XrSpatialComponentMesh2DListEXT; + +typedef struct XrSpatialPolygon2DDataEXT { + XrPosef origin; + XrSpatialBufferEXT vertexBuffer; +} XrSpatialPolygon2DDataEXT; + +// XrSpatialComponentPolygon2DListEXT extends XrSpatialComponentDataQueryResultEXT +typedef struct XrSpatialComponentPolygon2DListEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t polygonCount; + XrSpatialPolygon2DDataEXT* polygons; +} XrSpatialComponentPolygon2DListEXT; + +// XrSpatialComponentPlaneSemanticLabelListEXT extends XrSpatialComponentDataQueryResultEXT +typedef struct XrSpatialComponentPlaneSemanticLabelListEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t semanticLabelCount; + XrSpatialPlaneSemanticLabelEXT* semanticLabels; +} XrSpatialComponentPlaneSemanticLabelListEXT; + + + +// XR_EXT_stationary_reference_space is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_stationary_reference_space 1 +#define XR_EXT_stationary_reference_space_SPEC_VERSION 1 +#define XR_EXT_STATIONARY_REFERENCE_SPACE_EXTENSION_NAME "XR_EXT_stationary_reference_space" +typedef struct XrStationaryReferenceSpaceGenerationIdGetInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrStationaryReferenceSpaceGenerationIdGetInfoEXT; + +typedef struct XrStationaryReferenceSpaceGenerationIdResultEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrUuid generationId; +} XrStationaryReferenceSpaceGenerationIdResultEXT; + +typedef XrResult (XRAPI_PTR *PFN_xrGetStationaryReferenceSpaceGenerationIdEXT)(XrSession session, const XrStationaryReferenceSpaceGenerationIdGetInfoEXT* getInfo, XrStationaryReferenceSpaceGenerationIdResultEXT* generationIdResult); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetStationaryReferenceSpaceGenerationIdEXT( + XrSession session, + const XrStationaryReferenceSpaceGenerationIdGetInfoEXT* getInfo, + XrStationaryReferenceSpaceGenerationIdResultEXT* generationIdResult); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_EXT_spatial_marker_tracking is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_spatial_marker_tracking 1 +#define XR_EXT_spatial_marker_tracking_SPEC_VERSION 1 +#define XR_EXT_SPATIAL_MARKER_TRACKING_EXTENSION_NAME "XR_EXT_spatial_marker_tracking" + +typedef enum XrSpatialMarkerArucoDictEXT { + XR_SPATIAL_MARKER_ARUCO_DICT_4X4_50_EXT = 1, + XR_SPATIAL_MARKER_ARUCO_DICT_4X4_100_EXT = 2, + XR_SPATIAL_MARKER_ARUCO_DICT_4X4_250_EXT = 3, + XR_SPATIAL_MARKER_ARUCO_DICT_4X4_1000_EXT = 4, + XR_SPATIAL_MARKER_ARUCO_DICT_5X5_50_EXT = 5, + XR_SPATIAL_MARKER_ARUCO_DICT_5X5_100_EXT = 6, + XR_SPATIAL_MARKER_ARUCO_DICT_5X5_250_EXT = 7, + XR_SPATIAL_MARKER_ARUCO_DICT_5X5_1000_EXT = 8, + XR_SPATIAL_MARKER_ARUCO_DICT_6X6_50_EXT = 9, + XR_SPATIAL_MARKER_ARUCO_DICT_6X6_100_EXT = 10, + XR_SPATIAL_MARKER_ARUCO_DICT_6X6_250_EXT = 11, + XR_SPATIAL_MARKER_ARUCO_DICT_6X6_1000_EXT = 12, + XR_SPATIAL_MARKER_ARUCO_DICT_7X7_50_EXT = 13, + XR_SPATIAL_MARKER_ARUCO_DICT_7X7_100_EXT = 14, + XR_SPATIAL_MARKER_ARUCO_DICT_7X7_250_EXT = 15, + XR_SPATIAL_MARKER_ARUCO_DICT_7X7_1000_EXT = 16, + XR_SPATIAL_MARKER_ARUCO_DICT_MAX_ENUM_EXT = 0x7FFFFFFF +} XrSpatialMarkerArucoDictEXT; + +typedef enum XrSpatialMarkerAprilTagDictEXT { + XR_SPATIAL_MARKER_APRIL_TAG_DICT_16H5_EXT = 1, + XR_SPATIAL_MARKER_APRIL_TAG_DICT_25H9_EXT = 2, + XR_SPATIAL_MARKER_APRIL_TAG_DICT_36H10_EXT = 3, + XR_SPATIAL_MARKER_APRIL_TAG_DICT_36H11_EXT = 4, + XR_SPATIAL_MARKER_APRIL_TAG_DICT_MAX_ENUM_EXT = 0x7FFFFFFF +} XrSpatialMarkerAprilTagDictEXT; +typedef struct XrSpatialCapabilityConfigurationQrCodeEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialCapabilityEXT capability; + uint32_t enabledComponentCount; + const XrSpatialComponentTypeEXT* enabledComponents; +} XrSpatialCapabilityConfigurationQrCodeEXT; + +typedef struct XrSpatialCapabilityConfigurationMicroQrCodeEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialCapabilityEXT capability; + uint32_t enabledComponentCount; + const XrSpatialComponentTypeEXT* enabledComponents; +} XrSpatialCapabilityConfigurationMicroQrCodeEXT; + +typedef struct XrSpatialCapabilityConfigurationArucoMarkerEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialCapabilityEXT capability; + uint32_t enabledComponentCount; + const XrSpatialComponentTypeEXT* enabledComponents; + XrSpatialMarkerArucoDictEXT arUcoDict; +} XrSpatialCapabilityConfigurationArucoMarkerEXT; + +typedef struct XrSpatialCapabilityConfigurationAprilTagEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialCapabilityEXT capability; + uint32_t enabledComponentCount; + const XrSpatialComponentTypeEXT* enabledComponents; + XrSpatialMarkerAprilTagDictEXT aprilDict; +} XrSpatialCapabilityConfigurationAprilTagEXT; + +// XrSpatialMarkerSizeEXT extends XrSpatialCapabilityConfigurationArucoMarkerEXT,XrSpatialCapabilityConfigurationAprilTagEXT,XrSpatialCapabilityConfigurationQrCodeEXT,XrSpatialCapabilityConfigurationMicroQrCodeEXT +typedef struct XrSpatialMarkerSizeEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + float markerSideLength; +} XrSpatialMarkerSizeEXT; + +// XrSpatialMarkerStaticOptimizationEXT extends XrSpatialCapabilityConfigurationArucoMarkerEXT,XrSpatialCapabilityConfigurationAprilTagEXT,XrSpatialCapabilityConfigurationQrCodeEXT,XrSpatialCapabilityConfigurationMicroQrCodeEXT +typedef struct XrSpatialMarkerStaticOptimizationEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 optimizeForStaticMarker; +} XrSpatialMarkerStaticOptimizationEXT; + +typedef struct XrSpatialMarkerDataEXT { + XrSpatialCapabilityEXT capability; + uint32_t markerId; + XrSpatialBufferEXT data; +} XrSpatialMarkerDataEXT; + +// XrSpatialComponentMarkerListEXT extends XrSpatialComponentDataQueryResultEXT +typedef struct XrSpatialComponentMarkerListEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t markerCount; + XrSpatialMarkerDataEXT* markers; +} XrSpatialComponentMarkerListEXT; + + + +// XR_LOGITECH_mx_ink_stylus_interaction is a preprocessor guard. Do not pass it to API calls. +#define XR_LOGITECH_mx_ink_stylus_interaction 1 +#define XR_LOGITECH_mx_ink_stylus_interaction_SPEC_VERSION 1 +#define XR_LOGITECH_MX_INK_STYLUS_INTERACTION_EXTENSION_NAME "XR_LOGITECH_mx_ink_stylus_interaction" + + +// XR_BD_dynamic_object_tracking is a preprocessor guard. Do not pass it to API calls. +#define XR_BD_dynamic_object_tracking 1 +#define XR_BD_dynamic_object_tracking_SPEC_VERSION 1 +#define XR_BD_DYNAMIC_OBJECT_TRACKING_EXTENSION_NAME "XR_BD_dynamic_object_tracking" + +typedef enum XrDynamicObjectTypeBD { + XR_DYNAMIC_OBJECT_TYPE_UNKNOWN_BD = 0, + XR_DYNAMIC_OBJECT_TYPE_KEYBOARD_BD = 1000747000, + XR_DYNAMIC_OBJECT_TYPE_MOUSE_BD = 1000748000, + XR_DYNAMIC_OBJECT_TYPE_MAX_ENUM_BD = 0x7FFFFFFF +} XrDynamicObjectTypeBD; +// XrSystemDynamicObjectTrackingPropertiesBD extends XrSystemProperties +typedef struct XrSystemDynamicObjectTrackingPropertiesBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsDynamicObjectTracking; +} XrSystemDynamicObjectTrackingPropertiesBD; + +// XrSenseDataProviderCreateInfoDynamicObjectBD extends XrSenseDataProviderCreateInfoBD +typedef struct XrSenseDataProviderCreateInfoDynamicObjectBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t trackingTypeCount; + const XrDynamicObjectTypeBD* trackingTypes; +} XrSenseDataProviderCreateInfoDynamicObjectBD; + +typedef struct XrDynamicObjectDataBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrDynamicObjectTypeBD objectType; +} XrDynamicObjectDataBD; + +// XrSpatialEntityComponentDataDynamicObjectBD extends XrSpatialEntityComponentDataBaseHeaderBD +typedef struct XrSpatialEntityComponentDataDynamicObjectBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrDynamicObjectDataBD data; +} XrSpatialEntityComponentDataDynamicObjectBD; + +// XrSenseDataFilterDynamicObjectTypeBD extends XrSenseDataQueryInfoBD +typedef struct XrSenseDataFilterDynamicObjectTypeBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t typeCount; + const XrDynamicObjectTypeBD* types; +} XrSenseDataFilterDynamicObjectTypeBD; + + + +// XR_BD_dynamic_object_keyboard is a preprocessor guard. Do not pass it to API calls. +#define XR_BD_dynamic_object_keyboard 1 +#define XR_BD_dynamic_object_keyboard_SPEC_VERSION 1 +#define XR_BD_DYNAMIC_OBJECT_KEYBOARD_EXTENSION_NAME "XR_BD_dynamic_object_keyboard" +// XrSystemDynamicObjectKeyboardPropertiesBD extends XrSystemProperties +typedef struct XrSystemDynamicObjectKeyboardPropertiesBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsDynamicObjectKeyboard; +} XrSystemDynamicObjectKeyboardPropertiesBD; + + + +// XR_BD_dynamic_object_mouse is a preprocessor guard. Do not pass it to API calls. +#define XR_BD_dynamic_object_mouse 1 +#define XR_BD_dynamic_object_mouse_SPEC_VERSION 1 +#define XR_BD_DYNAMIC_OBJECT_MOUSE_EXTENSION_NAME "XR_BD_dynamic_object_mouse" +// XrSystemDynamicObjectMousePropertiesBD extends XrSystemProperties +typedef struct XrSystemDynamicObjectMousePropertiesBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsDynamicObjectMouse; +} XrSystemDynamicObjectMousePropertiesBD; + + + +// XR_BD_camera_image is a preprocessor guard. Do not pass it to API calls. +#define XR_BD_camera_image 1 +XR_DEFINE_ATOM(XrCameraIdBD) +XR_DEFINE_ATOM(XrCameraImageIdBD) +XR_DEFINE_HANDLE(XrCameraDeviceBD) +XR_DEFINE_HANDLE(XrCameraCaptureSessionBD) +#define XR_BD_camera_image_SPEC_VERSION 1 +#define XR_BD_CAMERA_IMAGE_EXTENSION_NAME "XR_BD_camera_image" + +typedef enum XrCameraPropertyTypeBD { + XR_CAMERA_PROPERTY_TYPE_FACING_BD = 1, + XR_CAMERA_PROPERTY_TYPE_POSITION_BD = 2, + XR_CAMERA_PROPERTY_TYPE_CAMERA_TYPE_BD = 3, + XR_CAMERA_PROPERTY_TYPE_MAX_ENUM_BD = 0x7FFFFFFF +} XrCameraPropertyTypeBD; + +typedef enum XrCameraFacingBD { + XR_CAMERA_FACING_WORLD_BD = 1, + XR_CAMERA_FACING_MAX_ENUM_BD = 0x7FFFFFFF +} XrCameraFacingBD; + +typedef enum XrCameraPositionBD { + XR_CAMERA_POSITION_UNSPECIFIED_BD = 1, + XR_CAMERA_POSITION_LEFT_BD = 2, + XR_CAMERA_POSITION_RIGHT_BD = 3, + XR_CAMERA_POSITION_MAX_ENUM_BD = 0x7FFFFFFF +} XrCameraPositionBD; + +typedef enum XrCameraTypeBD { + XR_CAMERA_TYPE_PASSTHROUGH_COLOR_BD = 1, + XR_CAMERA_TYPE_MAX_ENUM_BD = 0x7FFFFFFF +} XrCameraTypeBD; + +typedef enum XrCameraCapabilityTypeBD { + XR_CAMERA_CAPABILITY_TYPE_IMAGE_RESOLUTION_AND_FRAME_RATE_BD = 1, + XR_CAMERA_CAPABILITY_TYPE_IMAGE_FORMAT_BD = 2, + XR_CAMERA_CAPABILITY_TYPE_DATA_TRANSFER_TYPE_BD = 3, + XR_CAMERA_CAPABILITY_TYPE_CAMERA_MODEL_BD = 4, + XR_CAMERA_CAPABILITY_TYPE_MAX_ENUM_BD = 0x7FFFFFFF +} XrCameraCapabilityTypeBD; + +typedef enum XrCameraDataTransferTypeBD { + XR_CAMERA_DATA_TRANSFER_TYPE_RAW_BUFFER_BD = 1, + XR_CAMERA_DATA_TRANSFER_TYPE_MAX_ENUM_BD = 0x7FFFFFFF +} XrCameraDataTransferTypeBD; + +typedef enum XrCameraImageFormatBD { + XR_CAMERA_IMAGE_FORMAT_RGBA_8888_BD = 1, + XR_CAMERA_IMAGE_FORMAT_MAX_ENUM_BD = 0x7FFFFFFF +} XrCameraImageFormatBD; + +typedef enum XrCameraModelBD { + XR_CAMERA_MODEL_PINHOLE_BD = 1, + XR_CAMERA_MODEL_MAX_ENUM_BD = 0x7FFFFFFF +} XrCameraModelBD; +typedef struct XR_MAY_ALIAS XrCameraPropertyBaseHeaderBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrCameraPropertyBaseHeaderBD; + +typedef struct XrCameraPropertiesBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t propertyCount; + XrCameraPropertyBaseHeaderBD** properties; +} XrCameraPropertiesBD; + +typedef struct XR_MAY_ALIAS XrCameraCapabilityBaseHeaderBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrCameraCapabilityBaseHeaderBD; + +typedef struct XrCameraCapabilitiesBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t capabilityCount; + XrCameraCapabilityBaseHeaderBD** capabilities; +} XrCameraCapabilitiesBD; + +typedef struct XrAvailableCamerasEnumerateInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + const XrCameraPropertiesBD* properties; + const XrCameraCapabilitiesBD* capabilities; +} XrAvailableCamerasEnumerateInfoBD; + +typedef struct XrAvailableCameraBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrCameraIdBD cameraId; +} XrAvailableCameraBD; + +typedef struct XrCameraPropertyTypesEnumerateInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCameraIdBD cameraId; +} XrCameraPropertyTypesEnumerateInfoBD; + +typedef struct XrCameraPropertyTypesBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t propertyTypeCapacityInput; + uint32_t propertyTypeCountOutput; + XrCameraPropertyTypeBD* propertyTypes; +} XrCameraPropertyTypesBD; + +typedef struct XrCameraPropertiesGetInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCameraIdBD cameraId; +} XrCameraPropertiesGetInfoBD; + +typedef struct XrCameraPropertyFacingBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCameraFacingBD facing; +} XrCameraPropertyFacingBD; + +typedef struct XrCameraPropertyPositionBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCameraPositionBD position; +} XrCameraPropertyPositionBD; + +typedef struct XrCameraPropertyCameraTypeBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCameraTypeBD cameraType; +} XrCameraPropertyCameraTypeBD; + +typedef struct XrCameraCapabilityTypesEnumerateInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCameraIdBD cameraId; +} XrCameraCapabilityTypesEnumerateInfoBD; + +typedef struct XrCameraCapabilityTypesBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t capabilityTypeCapacityInput; + uint32_t capabilityTypeCountOutput; + XrCameraCapabilityTypeBD* capabilityTypes; +} XrCameraCapabilityTypesBD; + +typedef struct XrCameraSupportedCapabilitiesGetInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCameraIdBD id; +} XrCameraSupportedCapabilitiesGetInfoBD; + +typedef struct XR_MAY_ALIAS XrCameraSupportedCapabilityBaseHeaderBD { + XrStructureType type; + void* XR_MAY_ALIAS next; +} XrCameraSupportedCapabilityBaseHeaderBD; + +typedef struct XrCameraSupportedCapabilitiesBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t capabilityCount; + XrCameraSupportedCapabilityBaseHeaderBD** capabilities; +} XrCameraSupportedCapabilitiesBD; + +typedef struct XrCameraImageResolutionAndFrameRateBD { + XrExtent2Di resolution; + uint32_t frameRate; +} XrCameraImageResolutionAndFrameRateBD; + +typedef struct XrCameraSupportedCapabilityImageResolutionAndFrameRateBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t resolutionAndFrameRateCapacityInput; + uint32_t resolutionAndFrameRateCountOutput; + XrCameraImageResolutionAndFrameRateBD* resolutionAndFrameRates; +} XrCameraSupportedCapabilityImageResolutionAndFrameRateBD; + +typedef struct XrCameraCapabilityImageResolutionAndFrameRateBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrExtent2Di resolution; + uint32_t frameRate; +} XrCameraCapabilityImageResolutionAndFrameRateBD; + +typedef struct XrCameraSupportedCapabilityDataTransferTypeBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t transferTypeCapacityInput; + uint32_t transferTypeCountOutput; + XrCameraDataTransferTypeBD* transferTypes; +} XrCameraSupportedCapabilityDataTransferTypeBD; + +typedef struct XrCameraCapabilityDataTransferTypeBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCameraDataTransferTypeBD transferType; +} XrCameraCapabilityDataTransferTypeBD; + +typedef struct XrCameraSupportedCapabilityImageFormatBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t formatCapacityInput; + uint32_t formatCountOutput; + XrCameraImageFormatBD* formats; +} XrCameraSupportedCapabilityImageFormatBD; + +typedef struct XrCameraCapabilityImageFormatBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCameraImageFormatBD format; +} XrCameraCapabilityImageFormatBD; + +typedef struct XrCameraSupportedCapabilityCameraModelBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t modelCapacityInput; + uint32_t modelCountOutput; + XrCameraModelBD* models; +} XrCameraSupportedCapabilityCameraModelBD; + +typedef struct XrCameraCapabilityCameraModelBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCameraModelBD model; +} XrCameraCapabilityCameraModelBD; + +typedef struct XrCameraDeviceCreateInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCameraIdBD cameraId; +} XrCameraDeviceCreateInfoBD; + +typedef struct XrCreateCameraDeviceCompletionBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrResult futureResult; + XrCameraDeviceBD device; +} XrCreateCameraDeviceCompletionBD; + +typedef struct XrCameraCaptureSessionCreateInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrCameraDeviceBD camera; + uint32_t configCount; + const XrCameraCapabilityBaseHeaderBD* const* configs; +} XrCameraCaptureSessionCreateInfoBD; + +typedef struct XrCreateCameraCaptureSessionCompletionBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrResult futureResult; + XrCameraCaptureSessionBD captureSession; +} XrCreateCameraCaptureSessionCompletionBD; + +// XrCameraIntrinsicsBD extends XrCameraImageDataBaseHeaderBD +typedef struct XrCameraIntrinsicsBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrVector2f focalLength; + XrVector2f principalPoint; + XrVector2f fov; +} XrCameraIntrinsicsBD; + +// XrCameraExtrinsicsBD extends XrCameraImageDataBaseHeaderBD +typedef struct XrCameraExtrinsicsBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrPosef pose; +} XrCameraExtrinsicsBD; + +typedef struct XrCameraCaptureBeginInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrCameraCaptureBeginInfoBD; + +typedef struct XrCameraImageAcquireInfoBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrTime lastCaptureTime; +} XrCameraImageAcquireInfoBD; + +typedef struct XrCameraImageBD { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 available; + XrTime captureTime; + XrCameraImageIdBD imageId; +} XrCameraImageBD; + +typedef struct XR_MAY_ALIAS XrCameraImageDataBaseHeaderBD { + XrStructureType type; + void* XR_MAY_ALIAS next; +} XrCameraImageDataBaseHeaderBD; + +typedef struct XrCameraImageDataRawBufferBD { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t width; + uint32_t height; + uint32_t stride; + uint32_t bytesPerPixel; + uint32_t pixelStride; + uint32_t bufferSize; + uint8_t* buffer; +} XrCameraImageDataRawBufferBD; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateAvailableCamerasBD)(XrInstance instance, const XrAvailableCamerasEnumerateInfoBD* enumerateInfo, uint32_t cameraCapacityInput, uint32_t* cameraCountOutput, XrAvailableCameraBD* cameras); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateCameraPropertyTypesBD)(XrInstance instance, const XrCameraPropertyTypesEnumerateInfoBD* enumerateInfo, XrCameraPropertyTypesBD* propertyTypes); +typedef XrResult (XRAPI_PTR *PFN_xrGetCameraPropertiesBD)(XrInstance instance, const XrCameraPropertiesGetInfoBD* getInfo, XrCameraPropertiesBD* properties); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateCameraCapabilityTypesBD)(XrInstance instance, const XrCameraCapabilityTypesEnumerateInfoBD* enumerateInfo, XrCameraCapabilityTypesBD* capabilityTypes); +typedef XrResult (XRAPI_PTR *PFN_xrGetCameraSupportedCapabilitiesBD)(XrInstance instance, const XrCameraSupportedCapabilitiesGetInfoBD* getInfo, XrCameraSupportedCapabilitiesBD* capabilities); +typedef XrResult (XRAPI_PTR *PFN_xrCreateCameraDeviceAsyncBD)(XrInstance instance, const XrCameraDeviceCreateInfoBD* createInfo, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrCreateCameraDeviceCompleteBD)(XrInstance instance, XrFutureEXT future, XrCreateCameraDeviceCompletionBD* completion); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyCameraDeviceBD)(XrCameraDeviceBD device); +typedef XrResult (XRAPI_PTR *PFN_xrCreateCameraCaptureSessionAsyncBD)(XrSession session, const XrCameraCaptureSessionCreateInfoBD* createInfo, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrCreateCameraCaptureSessionCompleteBD)(XrSession session, XrFutureEXT future, XrCreateCameraCaptureSessionCompletionBD* completion); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyCameraCaptureSessionBD)(XrCameraCaptureSessionBD captureSession); +typedef XrResult (XRAPI_PTR *PFN_xrBeginCameraCaptureBD)(XrCameraCaptureSessionBD captureSession, const XrCameraCaptureBeginInfoBD* beginInfo); +typedef XrResult (XRAPI_PTR *PFN_xrEndCameraCaptureBD)(XrCameraCaptureSessionBD captureSession); +typedef XrResult (XRAPI_PTR *PFN_xrAcquireCameraImageBD)(XrCameraCaptureSessionBD captureSession, const XrCameraImageAcquireInfoBD* acquireInfo, XrCameraImageBD* image); +typedef XrResult (XRAPI_PTR *PFN_xrGetCameraImageDataBD)(XrCameraCaptureSessionBD captureSession, XrCameraImageIdBD imageId, XrCameraImageDataBaseHeaderBD* imageData); +typedef XrResult (XRAPI_PTR *PFN_xrReleaseCameraImageBD)(XrCameraCaptureSessionBD captureSession, XrCameraImageIdBD imageId); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateAvailableCamerasBD( + XrInstance instance, + const XrAvailableCamerasEnumerateInfoBD* enumerateInfo, + uint32_t cameraCapacityInput, + uint32_t* cameraCountOutput, + XrAvailableCameraBD* cameras); + +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateCameraPropertyTypesBD( + XrInstance instance, + const XrCameraPropertyTypesEnumerateInfoBD* enumerateInfo, + XrCameraPropertyTypesBD* propertyTypes); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetCameraPropertiesBD( + XrInstance instance, + const XrCameraPropertiesGetInfoBD* getInfo, + XrCameraPropertiesBD* properties); + +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateCameraCapabilityTypesBD( + XrInstance instance, + const XrCameraCapabilityTypesEnumerateInfoBD* enumerateInfo, + XrCameraCapabilityTypesBD* capabilityTypes); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetCameraSupportedCapabilitiesBD( + XrInstance instance, + const XrCameraSupportedCapabilitiesGetInfoBD* getInfo, + XrCameraSupportedCapabilitiesBD* capabilities); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateCameraDeviceAsyncBD( + XrInstance instance, + const XrCameraDeviceCreateInfoBD* createInfo, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateCameraDeviceCompleteBD( + XrInstance instance, + XrFutureEXT future, + XrCreateCameraDeviceCompletionBD* completion); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyCameraDeviceBD( + XrCameraDeviceBD device); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateCameraCaptureSessionAsyncBD( + XrSession session, + const XrCameraCaptureSessionCreateInfoBD* createInfo, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateCameraCaptureSessionCompleteBD( + XrSession session, + XrFutureEXT future, + XrCreateCameraCaptureSessionCompletionBD* completion); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyCameraCaptureSessionBD( + XrCameraCaptureSessionBD captureSession); + +XRAPI_ATTR XrResult XRAPI_CALL xrBeginCameraCaptureBD( + XrCameraCaptureSessionBD captureSession, + const XrCameraCaptureBeginInfoBD* beginInfo); + +XRAPI_ATTR XrResult XRAPI_CALL xrEndCameraCaptureBD( + XrCameraCaptureSessionBD captureSession); + +XRAPI_ATTR XrResult XRAPI_CALL xrAcquireCameraImageBD( + XrCameraCaptureSessionBD captureSession, + const XrCameraImageAcquireInfoBD* acquireInfo, + XrCameraImageBD* image); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetCameraImageDataBD( + XrCameraCaptureSessionBD captureSession, + XrCameraImageIdBD imageId, + XrCameraImageDataBaseHeaderBD* imageData); + +XRAPI_ATTR XrResult XRAPI_CALL xrReleaseCameraImageBD( + XrCameraCaptureSessionBD captureSession, + XrCameraImageIdBD imageId); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ANDROID_spatial_discovery_bounds is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_spatial_discovery_bounds 1 +#define XR_ANDROID_spatial_discovery_bounds_SPEC_VERSION 1 +#define XR_ANDROID_SPATIAL_DISCOVERY_BOUNDS_EXTENSION_NAME "XR_ANDROID_spatial_discovery_bounds" +// XrSpatialBoundsSpherefANDROID extends XrSpatialDiscoverySnapshotCreateInfoEXT +typedef struct XrSpatialBoundsSpherefANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace space; + XrTime time; + XrSpheref sphere; +} XrSpatialBoundsSpherefANDROID; + +// XrSpatialBoundsBoxfANDROID extends XrSpatialDiscoverySnapshotCreateInfoEXT +typedef struct XrSpatialBoundsBoxfANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace space; + XrTime time; + XrBoxf box; +} XrSpatialBoundsBoxfANDROID; + +// XrSpatialBoundsFrustumfANDROID extends XrSpatialDiscoverySnapshotCreateInfoEXT +typedef struct XrSpatialBoundsFrustumfANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace space; + XrTime time; + XrFrustumf frustum; +} XrSpatialBoundsFrustumfANDROID; + + + +// XR_EXT_spatial_anchor is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_spatial_anchor 1 +#define XR_EXT_spatial_anchor_SPEC_VERSION 1 +#define XR_EXT_SPATIAL_ANCHOR_EXTENSION_NAME "XR_EXT_spatial_anchor" +typedef struct XrSpatialCapabilityConfigurationAnchorEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialCapabilityEXT capability; + uint32_t enabledComponentCount; + const XrSpatialComponentTypeEXT* enabledComponents; +} XrSpatialCapabilityConfigurationAnchorEXT; + +// XrSpatialComponentAnchorListEXT extends XrSpatialComponentDataQueryResultEXT +typedef struct XrSpatialComponentAnchorListEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t locationCount; + XrPosef* locations; +} XrSpatialComponentAnchorListEXT; + +typedef struct XrSpatialAnchorCreateInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace baseSpace; + XrTime time; + XrPosef pose; +} XrSpatialAnchorCreateInfoEXT; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorEXT)(XrSpatialContextEXT spatialContext, const XrSpatialAnchorCreateInfoEXT* createInfo, XrSpatialEntityIdEXT* anchorEntityId, XrSpatialEntityEXT* anchorEntity); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorEXT( + XrSpatialContextEXT spatialContext, + const XrSpatialAnchorCreateInfoEXT* createInfo, + XrSpatialEntityIdEXT* anchorEntityId, + XrSpatialEntityEXT* anchorEntity); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_EXT_spatial_persistence is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_spatial_persistence 1 +XR_DEFINE_HANDLE(XrSpatialPersistenceContextEXT) +#define XR_EXT_spatial_persistence_SPEC_VERSION 1 +#define XR_EXT_SPATIAL_PERSISTENCE_EXTENSION_NAME "XR_EXT_spatial_persistence" + +typedef enum XrSpatialPersistenceScopeEXT { + XR_SPATIAL_PERSISTENCE_SCOPE_SYSTEM_MANAGED_EXT = 1, + XR_SPATIAL_PERSISTENCE_SCOPE_LOCAL_ANCHORS_EXT = 1000781000, + XR_SPATIAL_PERSISTENCE_SCOPE_MAX_ENUM_EXT = 0x7FFFFFFF +} XrSpatialPersistenceScopeEXT; + +typedef enum XrSpatialPersistenceContextResultEXT { + XR_SPATIAL_PERSISTENCE_CONTEXT_RESULT_SUCCESS_EXT = 0, + XR_SPATIAL_PERSISTENCE_CONTEXT_RESULT_ENTITY_NOT_TRACKING_EXT = -1000781001, + XR_SPATIAL_PERSISTENCE_CONTEXT_RESULT_PERSIST_UUID_NOT_FOUND_EXT = -1000781002, + XR_SPATIAL_PERSISTENCE_CONTEXT_RESULT_MAX_ENUM_EXT = 0x7FFFFFFF +} XrSpatialPersistenceContextResultEXT; + +typedef enum XrSpatialPersistenceStateEXT { + XR_SPATIAL_PERSISTENCE_STATE_LOADED_EXT = 1, + XR_SPATIAL_PERSISTENCE_STATE_NOT_FOUND_EXT = 2, + XR_SPATIAL_PERSISTENCE_STATE_MAX_ENUM_EXT = 0x7FFFFFFF +} XrSpatialPersistenceStateEXT; +typedef struct XrSpatialPersistenceContextCreateInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialPersistenceScopeEXT scope; +} XrSpatialPersistenceContextCreateInfoEXT; + +typedef struct XrCreateSpatialPersistenceContextCompletionEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrResult futureResult; + XrSpatialPersistenceContextResultEXT createResult; + XrSpatialPersistenceContextEXT persistenceContext; +} XrCreateSpatialPersistenceContextCompletionEXT; + +// XrSpatialContextPersistenceConfigEXT extends XrSpatialContextCreateInfoEXT +typedef struct XrSpatialContextPersistenceConfigEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t persistenceContextCount; + const XrSpatialPersistenceContextEXT* persistenceContexts; +} XrSpatialContextPersistenceConfigEXT; + +// XrSpatialDiscoveryPersistenceUuidFilterEXT extends XrSpatialDiscoverySnapshotCreateInfoEXT,XrSpatialComponentDataQueryConditionEXT +typedef struct XrSpatialDiscoveryPersistenceUuidFilterEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t persistedUuidCount; + const XrUuid* persistedUuids; +} XrSpatialDiscoveryPersistenceUuidFilterEXT; + +typedef struct XrSpatialPersistenceDataEXT { + XrUuid persistUuid; + XrSpatialPersistenceStateEXT persistState; +} XrSpatialPersistenceDataEXT; + +// XrSpatialComponentPersistenceListEXT extends XrSpatialComponentDataQueryResultEXT +typedef struct XrSpatialComponentPersistenceListEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t persistDataCount; + XrSpatialPersistenceDataEXT* persistData; +} XrSpatialComponentPersistenceListEXT; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSpatialPersistenceScopesEXT)(XrInstance instance, XrSystemId systemId, uint32_t persistenceScopeCapacityInput, uint32_t* persistenceScopeCountOutput, XrSpatialPersistenceScopeEXT* persistenceScopes); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialPersistenceContextAsyncEXT)(XrSession session, const XrSpatialPersistenceContextCreateInfoEXT* createInfo, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialPersistenceContextCompleteEXT)(XrSession session, XrFutureEXT future, XrCreateSpatialPersistenceContextCompletionEXT* completion); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialPersistenceContextEXT)(XrSpatialPersistenceContextEXT persistenceContext); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSpatialPersistenceScopesEXT( + XrInstance instance, + XrSystemId systemId, + uint32_t persistenceScopeCapacityInput, + uint32_t* persistenceScopeCountOutput, + XrSpatialPersistenceScopeEXT* persistenceScopes); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialPersistenceContextAsyncEXT( + XrSession session, + const XrSpatialPersistenceContextCreateInfoEXT* createInfo, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialPersistenceContextCompleteEXT( + XrSession session, + XrFutureEXT future, + XrCreateSpatialPersistenceContextCompletionEXT* completion); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialPersistenceContextEXT( + XrSpatialPersistenceContextEXT persistenceContext); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_EXT_haptic_parametric is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_haptic_parametric 1 + +#define XR_HAPTIC_PARAMETRIC_MAX_POINTS_TRANSIENTS_EXT 500 + + +#define XR_HAPTIC_PARAMETRIC_VIBRATION_EXTEND_DURATION_EXT 50000000 + + +#define XR_HAPTIC_PARAMETRIC_FREQUENCY_MIN_HZ_EXT 1 + + +#define XR_HAPTIC_PARAMETRIC_FREQUENCY_MAX_HZ_EXT 1000 + +#define XR_EXT_haptic_parametric_SPEC_VERSION 1 +#define XR_EXT_HAPTIC_PARAMETRIC_EXTENSION_NAME "XR_EXT_haptic_parametric" + +typedef enum XrHapticParametricStreamFrameTypeEXT { + XR_HAPTIC_PARAMETRIC_STREAM_FRAME_TYPE_NONE_EXT = 0, + XR_HAPTIC_PARAMETRIC_STREAM_FRAME_TYPE_FIRST_FRAME_EXT = 1, + XR_HAPTIC_PARAMETRIC_STREAM_FRAME_TYPE_INTERMEDIATE_FRAME_EXT = 2, + XR_HAPTIC_PARAMETRIC_STREAM_FRAME_TYPE_LAST_FRAME_EXT = 3, + XR_HAPTIC_PARAMETRIC_STREAM_FRAME_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} XrHapticParametricStreamFrameTypeEXT; +typedef struct XrHapticParametricPropertiesEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrDuration idealFrameSubmissionRate; + XrDuration minimumFirstFrameDuration; + float minFrequencyHz; + float maxFrequencyHz; +} XrHapticParametricPropertiesEXT; + +typedef struct XrHapticParametricPointEXT { + XrDuration time; + float value; +} XrHapticParametricPointEXT; + +typedef struct XrHapticParametricTransientEXT { + XrDuration time; + float amplitude; + float frequency; +} XrHapticParametricTransientEXT; + +typedef struct XrHapticParametricVibrationEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t amplitudePointCount; + const XrHapticParametricPointEXT* amplitudePoints; + uint32_t frequencyPointCount; + const XrHapticParametricPointEXT* frequencyPoints; + uint32_t transientCount; + const XrHapticParametricTransientEXT* transients; + float minFrequencyHz; + float maxFrequencyHz; + XrHapticParametricStreamFrameTypeEXT streamFrameType; +} XrHapticParametricVibrationEXT; + +// XrSystemHapticParametricPropertiesEXT extends XrSystemProperties +typedef struct XrSystemHapticParametricPropertiesEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsParametricHaptics; +} XrSystemHapticParametricPropertiesEXT; + +typedef XrResult (XRAPI_PTR *PFN_xrHapticParametricGetPropertiesEXT)(XrSession session, const XrHapticActionInfo* hapticActionInfo, XrHapticParametricPropertiesEXT* parametricProperties); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrHapticParametricGetPropertiesEXT( + XrSession session, + const XrHapticActionInfo* hapticActionInfo, + XrHapticParametricPropertiesEXT* parametricProperties); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_SONY_swapchain_color_space is a preprocessor guard. Do not pass it to API calls. +#define XR_SONY_swapchain_color_space 1 +#define XR_SONY_swapchain_color_space_SPEC_VERSION 1 +#define XR_SONY_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "XR_SONY_swapchain_color_space" + +typedef enum XrColorSpaceSONY { + XR_COLOR_SPACE_SRGB_NONLINEAR_SONY = 0, + XR_COLOR_SPACE_DISPLAY_P3_LINEAR_SONY = 1, + XR_COLOR_SPACE_DISPLAY_P3_NONLINEAR_SONY = 2, + XR_COLOR_SPACE_DCI_P3_LINEAR_SONY = 3, + XR_COLOR_SPACE_DCI_P3_NONLINEAR_SONY = 4, + XR_COLOR_SPACE_EXTENDED_SRGB_LINEAR_SONY = 5, + XR_COLOR_SPACE_BT709_LINEAR_SONY = 6, + XR_COLOR_SPACE_BT709_NONLINEAR_SONY = 7, + XR_COLOR_SPACE_BT2020_LINEAR_SONY = 8, + XR_COLOR_SPACE_BT2020_PQ_SONY = 9, + XR_COLOR_SPACE_BT2020_HLG_SONY = 10, + XR_COLOR_SPACE_MAX_ENUM_SONY = 0x7FFFFFFF +} XrColorSpaceSONY; +typedef struct XrColorSpacesEnumerateInfoSONY { + XrStructureType type; + const void* XR_MAY_ALIAS next; + int64_t format; +} XrColorSpacesEnumerateInfoSONY; + +// XrSwapchainCreateInfoColorSpaceSONY extends XrSwapchainCreateInfo +typedef struct XrSwapchainCreateInfoColorSpaceSONY { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrColorSpaceSONY colorSpace; +} XrSwapchainCreateInfoColorSpaceSONY; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateColorSpacesSONY)(XrSession session, const XrColorSpacesEnumerateInfoSONY* enumerateInfo, uint32_t colorSpaceCapacityInput, uint32_t* colorSpaceCountOutput, XrColorSpaceSONY* colorSpaces); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateColorSpacesSONY( + XrSession session, + const XrColorSpacesEnumerateInfoSONY* enumerateInfo, + uint32_t colorSpaceCapacityInput, + uint32_t* colorSpaceCountOutput, + XrColorSpaceSONY* colorSpaces); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_SONY_hdr_metadata is a preprocessor guard. Do not pass it to API calls. +#define XR_SONY_hdr_metadata 1 +#define XR_SONY_hdr_metadata_SPEC_VERSION 1 +#define XR_SONY_HDR_METADATA_EXTENSION_NAME "XR_SONY_hdr_metadata" +typedef struct XrXYColorSONY { + float x; + float y; +} XrXYColorSONY; + +typedef struct XrHdrMetadataSONY { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrXYColorSONY displayPrimaryRed; + XrXYColorSONY displayPrimaryGreen; + XrXYColorSONY displayPrimaryBlue; + XrXYColorSONY whitePoint; + float maxLuminance; + float minLuminance; + float maxContentLightLevel; + float maxFrameAverageLightLevel; +} XrHdrMetadataSONY; + +typedef XrResult (XRAPI_PTR *PFN_xrSetHdrMetadataSONY)(XrSwapchain swapchain, const XrHdrMetadataSONY* hdrMetadata); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrSetHdrMetadataSONY( + XrSwapchain swapchain, + const XrHdrMetadataSONY* hdrMetadata); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_EXT_spatial_persistence_operations is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_spatial_persistence_operations 1 +#define XR_EXT_spatial_persistence_operations_SPEC_VERSION 1 +#define XR_EXT_SPATIAL_PERSISTENCE_OPERATIONS_EXTENSION_NAME "XR_EXT_spatial_persistence_operations" +typedef struct XrSpatialEntityPersistInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialContextEXT spatialContext; + XrSpatialEntityIdEXT spatialEntityId; +} XrSpatialEntityPersistInfoEXT; + +typedef struct XrPersistSpatialEntityCompletionEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrResult futureResult; + XrSpatialPersistenceContextResultEXT persistResult; + XrUuid persistUuid; +} XrPersistSpatialEntityCompletionEXT; + +typedef struct XrSpatialEntityUnpersistInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrUuid persistUuid; +} XrSpatialEntityUnpersistInfoEXT; + +typedef struct XrUnpersistSpatialEntityCompletionEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrResult futureResult; + XrSpatialPersistenceContextResultEXT unpersistResult; +} XrUnpersistSpatialEntityCompletionEXT; + +typedef XrResult (XRAPI_PTR *PFN_xrPersistSpatialEntityAsyncEXT)(XrSpatialPersistenceContextEXT persistenceContext, const XrSpatialEntityPersistInfoEXT* persistInfo, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrPersistSpatialEntityCompleteEXT)(XrSpatialPersistenceContextEXT persistenceContext, XrFutureEXT future, XrPersistSpatialEntityCompletionEXT* completion); +typedef XrResult (XRAPI_PTR *PFN_xrUnpersistSpatialEntityAsyncEXT)(XrSpatialPersistenceContextEXT persistenceContext, const XrSpatialEntityUnpersistInfoEXT* unpersistInfo, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrUnpersistSpatialEntityCompleteEXT)(XrSpatialPersistenceContextEXT persistenceContext, XrFutureEXT future, XrUnpersistSpatialEntityCompletionEXT* completion); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrPersistSpatialEntityAsyncEXT( + XrSpatialPersistenceContextEXT persistenceContext, + const XrSpatialEntityPersistInfoEXT* persistInfo, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrPersistSpatialEntityCompleteEXT( + XrSpatialPersistenceContextEXT persistenceContext, + XrFutureEXT future, + XrPersistSpatialEntityCompletionEXT* completion); + +XRAPI_ATTR XrResult XRAPI_CALL xrUnpersistSpatialEntityAsyncEXT( + XrSpatialPersistenceContextEXT persistenceContext, + const XrSpatialEntityUnpersistInfoEXT* unpersistInfo, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrUnpersistSpatialEntityCompleteEXT( + XrSpatialPersistenceContextEXT persistenceContext, + XrFutureEXT future, + XrUnpersistSpatialEntityCompletionEXT* completion); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_EXT_spatial_image_tracking is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_spatial_image_tracking 1 +XR_DEFINE_HANDLE(XrSpatialImageTrackingDatabaseEXT) +#define XR_EXT_spatial_image_tracking_SPEC_VERSION 1 +#define XR_EXT_SPATIAL_IMAGE_TRACKING_EXTENSION_NAME "XR_EXT_spatial_image_tracking" + +typedef enum XrSpatialReferenceImageFormatEXT { + XR_SPATIAL_REFERENCE_IMAGE_FORMAT_RGBA_8888_EXT = 1, + XR_SPATIAL_REFERENCE_IMAGE_FORMAT_RGB_888_EXT = 2, + XR_SPATIAL_REFERENCE_IMAGE_FORMAT_YUV_420_888_EXT = 3, + XR_SPATIAL_REFERENCE_IMAGE_FORMAT_MAX_ENUM_EXT = 0x7FFFFFFF +} XrSpatialReferenceImageFormatEXT; +typedef struct XrSpatialReferenceImagePlaneEXT { + uint32_t bufferSize; + const uint8_t* buffer; + uint32_t rowStride; + uint32_t pixelStride; +} XrSpatialReferenceImagePlaneEXT; + +typedef struct XrSpatialReferenceImageEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t width; + uint32_t height; + XrSpatialReferenceImageFormatEXT format; + uint32_t planeCount; + const XrSpatialReferenceImagePlaneEXT* planes; +} XrSpatialReferenceImageEXT; + +// XrSpatialImageStaticOptimizationEXT extends XrSpatialReferenceImageEXT,XrSpatialImageTrackingDatabaseCreateInfoEXT +typedef struct XrSpatialImageStaticOptimizationEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 optimizeForStaticImage; +} XrSpatialImageStaticOptimizationEXT; + +// XrSpatialImageSizeEXT extends XrSpatialReferenceImageEXT,XrSpatialImageTrackingDatabaseCreateInfoEXT +typedef struct XrSpatialImageSizeEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + float physicalWidth; +} XrSpatialImageSizeEXT; + +typedef struct XrSpatialCapabilityConfigurationImageTrackingEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialCapabilityEXT capability; + uint32_t enabledComponentCount; + const XrSpatialComponentTypeEXT* enabledComponents; + uint32_t imageTrackingDatabaseCount; + const XrSpatialImageTrackingDatabaseEXT* imageTrackingDatabases; +} XrSpatialCapabilityConfigurationImageTrackingEXT; + +typedef struct XrSpatialImageTrackingDatabaseCreateInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t spatialReferenceImageCount; + const XrSpatialReferenceImageEXT* spatialReferenceImages; +} XrSpatialImageTrackingDatabaseCreateInfoEXT; + +typedef struct XrSpatialImage2DDataEXT { + XrSpatialImageTrackingDatabaseEXT imageTrackingDatabase; + uint32_t referenceImageIndex; +} XrSpatialImage2DDataEXT; + +// XrSpatialComponentImage2DListEXT extends XrSpatialComponentDataQueryResultEXT +typedef struct XrSpatialComponentImage2DListEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t imageCount; + XrSpatialImage2DDataEXT* images; +} XrSpatialComponentImage2DListEXT; + +typedef struct XrCreateSpatialImageTrackingDatabaseCompletionEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrResult futureResult; + XrSpatialImageTrackingDatabaseEXT database; +} XrCreateSpatialImageTrackingDatabaseCompletionEXT; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSpatialReferenceImageFormatsEXT)(XrInstance instance, XrSystemId systemId, XrSpatialCapabilityEXT capability, uint32_t formatCapacityInput, uint32_t* formatCountOutput, XrSpatialReferenceImageFormatEXT* formats); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialImageTrackingDatabaseAsyncEXT)(XrSession session, const XrSpatialImageTrackingDatabaseCreateInfoEXT* createInfo, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialImageTrackingDatabaseCompleteEXT)(XrSession session, XrFutureEXT future, XrCreateSpatialImageTrackingDatabaseCompletionEXT* completion); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialImageTrackingDatabaseEXT)(XrSpatialImageTrackingDatabaseEXT database); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSpatialReferenceImageFormatsEXT( + XrInstance instance, + XrSystemId systemId, + XrSpatialCapabilityEXT capability, + uint32_t formatCapacityInput, + uint32_t* formatCountOutput, + XrSpatialReferenceImageFormatEXT* formats); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialImageTrackingDatabaseAsyncEXT( + XrSession session, + const XrSpatialImageTrackingDatabaseCreateInfoEXT* createInfo, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialImageTrackingDatabaseCompleteEXT( + XrSession session, + XrFutureEXT future, + XrCreateSpatialImageTrackingDatabaseCompletionEXT* completion); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialImageTrackingDatabaseEXT( + XrSpatialImageTrackingDatabaseEXT database); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ANDROID_spatial_object_tracking is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_spatial_object_tracking 1 +#define XR_ANDROID_spatial_object_tracking_SPEC_VERSION 2 +#define XR_ANDROID_SPATIAL_OBJECT_TRACKING_EXTENSION_NAME "XR_ANDROID_spatial_object_tracking" + +typedef enum XrSpatialObjectSemanticLabelANDROID { + XR_SPATIAL_OBJECT_SEMANTIC_LABEL_UNCATEGORIZED_ANDROID = 0, + XR_SPATIAL_OBJECT_SEMANTIC_LABEL_KEYBOARD_ANDROID = 1, + XR_SPATIAL_OBJECT_SEMANTIC_LABEL_MOUSE_ANDROID = 2, + XR_SPATIAL_OBJECT_SEMANTIC_LABEL_LAPTOP_BASE_ANDROID = 3, + XR_SPATIAL_OBJECT_SEMANTIC_LABEL_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrSpatialObjectSemanticLabelANDROID; +typedef struct XrSpatialCapabilityConfigurationObjectTrackingANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialCapabilityEXT capability; + uint32_t enabledComponentCount; + const XrSpatialComponentTypeEXT* enabledComponents; + uint32_t activeSemanticLabelCount; + const XrSpatialObjectSemanticLabelANDROID* activeSemanticLabels; +} XrSpatialCapabilityConfigurationObjectTrackingANDROID; + +// XrSpatialComponentObjectSemanticLabelListANDROID extends XrSpatialComponentDataQueryResultEXT +typedef struct XrSpatialComponentObjectSemanticLabelListANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t semanticLabelCount; + XrSpatialObjectSemanticLabelANDROID* semanticLabels; +} XrSpatialComponentObjectSemanticLabelListANDROID; + + + +// XR_ANDROID_spatial_discovery_raycast is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_spatial_discovery_raycast 1 +#define XR_ANDROID_spatial_discovery_raycast_SPEC_VERSION 1 +#define XR_ANDROID_SPATIAL_DISCOVERY_RAYCAST_EXTENSION_NAME "XR_ANDROID_spatial_discovery_raycast" +typedef struct XrSpatialRaycastResultDataANDROID { + XrPosef hitPose; + float distanceSquared; +} XrSpatialRaycastResultDataANDROID; + +typedef struct XrSpatialCapabilityConfigurationDepthRaycastANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialCapabilityEXT capability; + uint32_t enabledComponentCount; + const XrSpatialComponentTypeEXT* enabledComponents; +} XrSpatialCapabilityConfigurationDepthRaycastANDROID; + +// XrSpatialRaycastInfoANDROID extends XrSpatialDiscoverySnapshotCreateInfoEXT +typedef struct XrSpatialRaycastInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace space; + XrTime time; + XrVector3f origin; + XrVector3f direction; + float maxDistance; +} XrSpatialRaycastInfoANDROID; + +// XrSpatialComponentRaycastResultListANDROID extends XrSpatialComponentDataQueryResultEXT +typedef struct XrSpatialComponentRaycastResultListANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t raycastResultCount; + XrSpatialRaycastResultDataANDROID* raycastResults; +} XrSpatialComponentRaycastResultListANDROID; + +typedef struct XrSpatialRaycastSnapshotCreateInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t componentTypeCount; + const XrSpatialComponentTypeEXT* componentTypes; + const XrSpatialRaycastInfoANDROID* raycastInfo; +} XrSpatialRaycastSnapshotCreateInfoANDROID; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialRaycastSnapshotANDROID)(XrSpatialContextEXT spatialContext, const XrSpatialRaycastSnapshotCreateInfoANDROID* createInfo, XrSpatialSnapshotEXT* snapshot); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialRaycastSnapshotANDROID( + XrSpatialContextEXT spatialContext, + const XrSpatialRaycastSnapshotCreateInfoANDROID* createInfo, + XrSpatialSnapshotEXT* snapshot); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ANDROID_google_cloud_auth is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_google_cloud_auth 1 +#define XR_ANDROID_google_cloud_auth_SPEC_VERSION 1 +#define XR_ANDROID_GOOGLE_CLOUD_AUTH_EXTENSION_NAME "XR_ANDROID_google_cloud_auth" + +typedef enum XrGoogleCloudAuthErrorANDROID { + XR_GOOGLE_CLOUD_AUTH_ERROR_NONE_ANDROID = 0, + XR_GOOGLE_CLOUD_AUTH_ERROR_QUOTA_EXCEEDED_ANDROID = -1, + XR_GOOGLE_CLOUD_AUTH_ERROR_UNREACHABLE_ANDROID = -2, + XR_GOOGLE_CLOUD_AUTH_ERROR_ANDROID = -3, + XR_GOOGLE_CLOUD_AUTH_ERROR_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrGoogleCloudAuthErrorANDROID; +typedef struct XR_MAY_ALIAS XrGoogleCloudAuthInfoBaseHeaderANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrGoogleCloudAuthInfoBaseHeaderANDROID; + +typedef struct XrGoogleCloudAuthInfoApiKeyANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + const char* apiKey; +} XrGoogleCloudAuthInfoApiKeyANDROID; + +typedef struct XrGoogleCloudAuthInfoTokenANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + const char* authToken; +} XrGoogleCloudAuthInfoTokenANDROID; + +typedef struct XrGoogleCloudAuthInfoKeylessANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrGoogleCloudAuthInfoKeylessANDROID; + +// XrGoogleCloudAuthErrorResultANDROID extends XrGoogleCloudAuthInfoBaseHeaderANDROID +typedef struct XrGoogleCloudAuthErrorResultANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrGoogleCloudAuthErrorANDROID error; +} XrGoogleCloudAuthErrorResultANDROID; + +typedef XrResult (XRAPI_PTR *PFN_xrSetGoogleCloudAuthAsyncANDROID)(XrSession session, const XrGoogleCloudAuthInfoBaseHeaderANDROID* authInfo, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrSetGoogleCloudAuthCompleteANDROID)(XrSession session, XrFutureEXT future, XrFutureCompletionEXT* completion); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrSetGoogleCloudAuthAsyncANDROID( + XrSession session, + const XrGoogleCloudAuthInfoBaseHeaderANDROID* authInfo, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrSetGoogleCloudAuthCompleteANDROID( + XrSession session, + XrFutureEXT future, + XrFutureCompletionEXT* completion); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ANDROID_geospatial is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_geospatial 1 +XR_DEFINE_HANDLE(XrGeospatialTrackerANDROID) +#define XR_ANDROID_geospatial_SPEC_VERSION 1 +#define XR_ANDROID_GEOSPATIAL_EXTENSION_NAME "XR_ANDROID_geospatial" + +typedef enum XrGeospatialTrackerStateANDROID { + XR_GEOSPATIAL_TRACKER_STATE_STOPPED_ANDROID = 0, + XR_GEOSPATIAL_TRACKER_STATE_RUNNING_ANDROID = 1, + XR_GEOSPATIAL_TRACKER_STATE_INITIALIZATION_FAILED_ANDROID = 2, + XR_GEOSPATIAL_TRACKER_STATE_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrGeospatialTrackerStateANDROID; + +typedef enum XrVPSAvailabilityANDROID { + XR_VPS_AVAILABILITY_UNAVAILABLE_ANDROID = 1, + XR_VPS_AVAILABILITY_AVAILABLE_ANDROID = 2, + XR_VPSAVAILABILITY_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrVPSAvailabilityANDROID; +typedef XrFlags64 XrGeospatialPoseFlagsANDROID; + +// Flag bits for XrGeospatialPoseFlagsANDROID +static const XrGeospatialPoseFlagsANDROID XR_GEOSPATIAL_POSE_ORIENTATION_VALID_BIT_ANDROID = 0x00000001; +static const XrGeospatialPoseFlagsANDROID XR_GEOSPATIAL_POSE_POSITION_VALID_BIT_ANDROID = 0x00000002; + +typedef struct XrGeospatialPoseANDROID { + XrQuaternionf eastUpSouthOrientation; + double latitude; + double longitude; + double altitude; +} XrGeospatialPoseANDROID; + +// XrSystemGeospatialPropertiesANDROID extends XrSystemProperties +typedef struct XrSystemGeospatialPropertiesANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsGeospatial; +} XrSystemGeospatialPropertiesANDROID; + +typedef struct XrGeospatialTrackerCreateInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrGeospatialTrackerCreateInfoANDROID; + +typedef struct XrEventDataGeospatialTrackerStateChangedANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrGeospatialTrackerANDROID geospatialTracker; + XrGeospatialTrackerStateANDROID state; + XrResult initializationResult; + XrTime time; +} XrEventDataGeospatialTrackerStateChangedANDROID; + +typedef struct XrGeospatialPoseFromPoseLocateInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace space; + XrTime time; + XrPosef pose; +} XrGeospatialPoseFromPoseLocateInfoANDROID; + +typedef struct XrGeospatialPoseResultANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrGeospatialPoseFlagsANDROID poseFlags; + XrGeospatialPoseANDROID geospatialPose; + double horizontalAccuracy; + double verticalAccuracy; + double orientationYawAccuracy; +} XrGeospatialPoseResultANDROID; + +typedef struct XrGeospatialPoseLocateInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace space; + XrTime time; + XrGeospatialPoseANDROID geospatialPose; +} XrGeospatialPoseLocateInfoANDROID; + +typedef struct XrVPSAvailabilityCheckCompletionANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrResult futureResult; + XrVPSAvailabilityANDROID availability; +} XrVPSAvailabilityCheckCompletionANDROID; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateGeospatialTrackerANDROID)(XrSession session, const XrGeospatialTrackerCreateInfoANDROID* createInfo, XrGeospatialTrackerANDROID* geospatialTrackerOutput); +typedef XrResult (XRAPI_PTR *PFN_xrDestroyGeospatialTrackerANDROID)(XrGeospatialTrackerANDROID geospatialTracker); +typedef XrResult (XRAPI_PTR *PFN_xrLocateGeospatialPoseFromPoseANDROID)(XrGeospatialTrackerANDROID geospatialTracker, const XrGeospatialPoseFromPoseLocateInfoANDROID* locateInfo, XrGeospatialPoseResultANDROID* geospatialPoseResult); +typedef XrResult (XRAPI_PTR *PFN_xrLocateGeospatialPoseANDROID)(XrGeospatialTrackerANDROID geospatialTracker, const XrGeospatialPoseLocateInfoANDROID* locateInfo, XrSpaceLocation* location); +typedef XrResult (XRAPI_PTR *PFN_xrCheckVpsAvailabilityAsyncANDROID)(XrSession session, double latitude, double longitude, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrCheckVpsAvailabilityCompleteANDROID)(XrSession session, XrFutureEXT future, XrVPSAvailabilityCheckCompletionANDROID* completion); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateGeospatialTrackerANDROID( + XrSession session, + const XrGeospatialTrackerCreateInfoANDROID* createInfo, + XrGeospatialTrackerANDROID* geospatialTrackerOutput); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroyGeospatialTrackerANDROID( + XrGeospatialTrackerANDROID geospatialTracker); + +XRAPI_ATTR XrResult XRAPI_CALL xrLocateGeospatialPoseFromPoseANDROID( + XrGeospatialTrackerANDROID geospatialTracker, + const XrGeospatialPoseFromPoseLocateInfoANDROID* locateInfo, + XrGeospatialPoseResultANDROID* geospatialPoseResult); + +XRAPI_ATTR XrResult XRAPI_CALL xrLocateGeospatialPoseANDROID( + XrGeospatialTrackerANDROID geospatialTracker, + const XrGeospatialPoseLocateInfoANDROID* locateInfo, + XrSpaceLocation* location); + +XRAPI_ATTR XrResult XRAPI_CALL xrCheckVpsAvailabilityAsyncANDROID( + XrSession session, + double latitude, + double longitude, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrCheckVpsAvailabilityCompleteANDROID( + XrSession session, + XrFutureEXT future, + XrVPSAvailabilityCheckCompletionANDROID* completion); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ANDROID_spatial_entity_bound_anchor is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_spatial_entity_bound_anchor 1 +#define XR_ANDROID_spatial_entity_bound_anchor_SPEC_VERSION 2 +#define XR_ANDROID_SPATIAL_ENTITY_BOUND_ANCHOR_EXTENSION_NAME "XR_ANDROID_spatial_entity_bound_anchor" +// XrSpatialAnchorParentANDROID extends XrSpatialAnchorCreateInfoEXT +typedef struct XrSpatialAnchorParentANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialEntityIdEXT parentId; +} XrSpatialAnchorParentANDROID; + +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSpatialAnchorAttachableComponentsANDROID)(XrInstance instance, XrSystemId systemId, uint32_t attachableComponentCapacityInput, uint32_t* attachableComponentCountOutput, XrSpatialComponentTypeEXT* attachableComponents); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSpatialAnchorAttachableComponentsANDROID( + XrInstance instance, + XrSystemId systemId, + uint32_t attachableComponentCapacityInput, + uint32_t* attachableComponentCountOutput, + XrSpatialComponentTypeEXT* attachableComponents); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ANDROID_spatial_component_subsumed_by is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_spatial_component_subsumed_by 1 +#define XR_ANDROID_spatial_component_subsumed_by_SPEC_VERSION 1 +#define XR_ANDROID_SPATIAL_COMPONENT_SUBSUMED_BY_EXTENSION_NAME "XR_ANDROID_spatial_component_subsumed_by" +// XrSpatialDiscoveryUniqueEntitiesFilterANDROID extends XrSpatialDiscoverySnapshotCreateInfoEXT +typedef struct XrSpatialDiscoveryUniqueEntitiesFilterANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrSpatialDiscoveryUniqueEntitiesFilterANDROID; + +// XrSpatialComponentSubsumedByListANDROID extends XrSpatialComponentDataQueryResultEXT +typedef struct XrSpatialComponentSubsumedByListANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t subsumedUniqueIdCount; + XrSpatialEntityIdEXT* subsumedUniqueIds; +} XrSpatialComponentSubsumedByListANDROID; + + + +// XR_ANDROID_spatial_anchor_space is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_spatial_anchor_space 1 +#define XR_ANDROID_spatial_anchor_space_SPEC_VERSION 1 +#define XR_ANDROID_SPATIAL_ANCHOR_SPACE_EXTENSION_NAME "XR_ANDROID_spatial_anchor_space" +typedef struct XrSpatialAnchorSpaceFromIdCreateInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialEntityIdEXT anchorEntityId; +} XrSpatialAnchorSpaceFromIdCreateInfoANDROID; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorSpaceANDROID)(XrSession session, XrSpatialContextEXT spatialContext, const XrSpatialAnchorCreateInfoEXT* createInfo, XrSpatialEntityIdEXT* anchorEntityId, XrSpace* anchorSpace); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorSpaceFromIdANDROID)(XrSession session, XrSpatialContextEXT spatialContext, const XrSpatialAnchorSpaceFromIdCreateInfoANDROID* createInfo, XrSpace* anchorSpace); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorSpaceANDROID( + XrSession session, + XrSpatialContextEXT spatialContext, + const XrSpatialAnchorCreateInfoEXT* createInfo, + XrSpatialEntityIdEXT* anchorEntityId, + XrSpace* anchorSpace); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorSpaceFromIdANDROID( + XrSession session, + XrSpatialContextEXT spatialContext, + const XrSpatialAnchorSpaceFromIdCreateInfoANDROID* createInfo, + XrSpace* anchorSpace); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_ANDROID_geospatial_anchor is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_geospatial_anchor 1 +#define XR_ANDROID_geospatial_anchor_SPEC_VERSION 1 +#define XR_ANDROID_GEOSPATIAL_ANCHOR_EXTENSION_NAME "XR_ANDROID_geospatial_anchor" + +typedef enum XrSurfaceAnchorTypeANDROID { + XR_SURFACE_ANCHOR_TYPE_TERRAIN_ANDROID = 1, + XR_SURFACE_ANCHOR_TYPE_ROOFTOP_ANDROID = 2, + XR_SURFACE_ANCHOR_TYPE_MAX_ENUM_ANDROID = 0x7FFFFFFF +} XrSurfaceAnchorTypeANDROID; +// XrSystemGeospatialAnchorPropertiesANDROID extends XrSystemProperties +typedef struct XrSystemGeospatialAnchorPropertiesANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t maxSurfaceAnchorCount; +} XrSystemGeospatialAnchorPropertiesANDROID; + +// XrGeospatialTrackerAnchorTrackingInfoANDROID extends XrGeospatialTrackerCreateInfoANDROID +typedef struct XrGeospatialTrackerAnchorTrackingInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 shouldTrackPlanes; +} XrGeospatialTrackerAnchorTrackingInfoANDROID; + +typedef struct XrGeospatialAnchorCreateInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrGeospatialTrackerANDROID geospatialTracker; + XrGeospatialPoseANDROID geospatialPose; +} XrGeospatialAnchorCreateInfoANDROID; + +typedef struct XrSurfaceAnchorCreateInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrGeospatialTrackerANDROID geospatialTracker; + XrSurfaceAnchorTypeANDROID surfaceAnchorType; + XrQuaternionf eastUpSouthOrientation; + double latitude; + double longitude; + double altitudeRelativeToSurface; +} XrSurfaceAnchorCreateInfoANDROID; + +typedef struct XrSurfaceAnchorCreateCompletionANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrResult futureResult; + XrSpatialEntityIdEXT anchorEntityId; +} XrSurfaceAnchorCreateCompletionANDROID; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateGeospatialAnchorANDROID)(XrSpatialContextEXT spatialContext, const XrGeospatialAnchorCreateInfoANDROID* createInfo, XrSpatialEntityIdEXT* anchorEntityId); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSurfaceAnchorAsyncANDROID)(XrSpatialContextEXT spatialContext, const XrSurfaceAnchorCreateInfoANDROID* createInfo, XrFutureEXT* future); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSurfaceAnchorCompleteANDROID)(XrSpatialContextEXT spatialContext, XrFutureEXT future, XrSurfaceAnchorCreateCompletionANDROID* completion); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateGeospatialAnchorANDROID( + XrSpatialContextEXT spatialContext, + const XrGeospatialAnchorCreateInfoANDROID* createInfo, + XrSpatialEntityIdEXT* anchorEntityId); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSurfaceAnchorAsyncANDROID( + XrSpatialContextEXT spatialContext, + const XrSurfaceAnchorCreateInfoANDROID* createInfo, + XrFutureEXT* future); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSurfaceAnchorCompleteANDROID( + XrSpatialContextEXT spatialContext, + XrFutureEXT future, + XrSurfaceAnchorCreateCompletionANDROID* completion); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_EXT_spatial_container is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_spatial_container 1 +XR_DEFINE_HANDLE(XrSpatialContainerEXT) +#define XR_EXT_spatial_container_SPEC_VERSION 1 +#define XR_EXT_SPATIAL_CONTAINER_EXTENSION_NAME "XR_EXT_spatial_container" + +typedef enum XrSpatialContainerGraphicsPresentationEXT { + XR_SPATIAL_CONTAINER_GRAPHICS_PRESENTATION_SELF_RENDERING_EXT = 1000813000, + XR_SPATIAL_CONTAINER_GRAPHICS_PRESENTATION_MAX_ENUM_EXT = 0x7FFFFFFF +} XrSpatialContainerGraphicsPresentationEXT; + +typedef enum XrSpatialContainerBoundsModeEXT { + XR_SPATIAL_CONTAINER_BOUNDS_MODE_BOUNDED_EXT = 1, + XR_SPATIAL_CONTAINER_BOUNDS_MODE_IMMERSIVE_EXT = 2, + XR_SPATIAL_CONTAINER_BOUNDS_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} XrSpatialContainerBoundsModeEXT; + +typedef enum XrSpatialContainerVolumeClippingEXT { + XR_SPATIAL_CONTAINER_VOLUME_CLIPPING_NONE_EXT = 0, + XR_SPATIAL_CONTAINER_VOLUME_CLIPPING_STRICT_EXT = 1, + XR_SPATIAL_CONTAINER_VOLUME_CLIPPING_MAX_ENUM_EXT = 0x7FFFFFFF +} XrSpatialContainerVolumeClippingEXT; +// XrSessionCreateInfoSpatialContainersEXT extends XrSessionCreateInfo +typedef struct XrSessionCreateInfoSpatialContainersEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrSessionCreateInfoSpatialContainersEXT; + +typedef struct XrSpatialContainerCreateInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialContainerGraphicsPresentationEXT graphicsPresentation; + XrExtent3Df suggestedBounds; +} XrSpatialContainerCreateInfoEXT; + +typedef struct XrSpatialContainerSpaceCreateInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialContainerEXT spatialContainer; +} XrSpatialContainerSpaceCreateInfoEXT; + +typedef struct XrEventDataSpatialContainerClosedEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialContainerEXT spatialContainer; +} XrEventDataSpatialContainerClosedEXT; + +// XrSystemSpatialContainerPropertiesEXT extends XrSystemProperties +typedef struct XrSystemSpatialContainerPropertiesEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t maxSpatialContainerCount; + XrBool32 supportsBounded; + XrBool32 supportsImmersive; +} XrSystemSpatialContainerPropertiesEXT; + +typedef struct XrSpatialContainerBoundsEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrExtent3Df bounds; + XrBool32 infiniteBounds; +} XrSpatialContainerBoundsEXT; + +typedef struct XrEventDataSpatialContainerBoundsChangedEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialContainerEXT spatialContainer; + XrExtent3Df bounds; + XrBool32 infiniteBounds; + XrSpatialContainerBoundsModeEXT boundsMode; +} XrEventDataSpatialContainerBoundsChangedEXT; + +typedef struct XrSpatialContainerBoundsGetInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrSpatialContainerBoundsGetInfoEXT; + +typedef struct XrSpatialContainerStateGetInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; +} XrSpatialContainerStateGetInfoEXT; + +typedef struct XrSpatialContainerVisibleRequestInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrBool32 visible; +} XrSpatialContainerVisibleRequestInfoEXT; + +typedef struct XrEventDataSpatialContainerVisibleChangedEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialContainerEXT spatialContainer; + XrBool32 visible; +} XrEventDataSpatialContainerVisibleChangedEXT; + +typedef struct XrEventDataSpatialContainerVisibleRequestDeniedEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialContainerEXT spatialContainer; +} XrEventDataSpatialContainerVisibleRequestDeniedEXT; + +typedef struct XrEventDataSpatialContainerInteractableChangedEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialContainerEXT spatialContainer; + XrBool32 interactable; +} XrEventDataSpatialContainerInteractableChangedEXT; + +typedef struct XrSpatialContainerBoundsModeRequestInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialContainerBoundsModeEXT boundsMode; +} XrSpatialContainerBoundsModeRequestInfoEXT; + +typedef struct XrEventDataSpatialContainerBoundsModeRequestDeniedEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialContainerEXT spatialContainer; +} XrEventDataSpatialContainerBoundsModeRequestDeniedEXT; + +typedef struct XrSpatialContainerStateEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 visible; + XrBool32 interactable; + XrSpatialContainerBoundsModeEXT boundsMode; +} XrSpatialContainerStateEXT; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialContainerEXT)(XrSession session, const XrSpatialContainerCreateInfoEXT* createInfo, XrSpatialContainerEXT* spatialContainer); +typedef XrResult (XRAPI_PTR *PFN_xrDestroySpatialContainerEXT)(XrSpatialContainerEXT spatialContainer); +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialContainerSpaceEXT)(XrSession session, const XrSpatialContainerSpaceCreateInfoEXT* createInfo, XrSpace* space); +typedef XrResult (XRAPI_PTR *PFN_xrRequestSpatialContainerVisibleEXT)(XrSpatialContainerEXT spatialContainer, const XrSpatialContainerVisibleRequestInfoEXT* info); +typedef XrResult (XRAPI_PTR *PFN_xrRequestSpatialContainerBoundsModeEXT)(XrSpatialContainerEXT spatialContainer, const XrSpatialContainerBoundsModeRequestInfoEXT* info); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialContainerBoundsEXT)(XrSpatialContainerEXT spatialContainer, const XrSpatialContainerBoundsGetInfoEXT* getInfo, XrSpatialContainerBoundsEXT* bounds); +typedef XrResult (XRAPI_PTR *PFN_xrGetSpatialContainerStateEXT)(XrSpatialContainerEXT spatialContainer, const XrSpatialContainerStateGetInfoEXT* getInfo, XrSpatialContainerStateEXT* state); +typedef XrResult (XRAPI_PTR *PFN_xrEnumerateSupportedSpatialContainerGraphicsPresentationsEXT)(XrInstance instance, XrSystemId systemId, uint32_t graphicsPresentationCapacityInput, uint32_t* graphicsPresentationCountOutput, XrSpatialContainerGraphicsPresentationEXT* graphicsPresentations); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialContainerEXT( + XrSession session, + const XrSpatialContainerCreateInfoEXT* createInfo, + XrSpatialContainerEXT* spatialContainer); + +XRAPI_ATTR XrResult XRAPI_CALL xrDestroySpatialContainerEXT( + XrSpatialContainerEXT spatialContainer); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialContainerSpaceEXT( + XrSession session, + const XrSpatialContainerSpaceCreateInfoEXT* createInfo, + XrSpace* space); + +XRAPI_ATTR XrResult XRAPI_CALL xrRequestSpatialContainerVisibleEXT( + XrSpatialContainerEXT spatialContainer, + const XrSpatialContainerVisibleRequestInfoEXT* info); + +XRAPI_ATTR XrResult XRAPI_CALL xrRequestSpatialContainerBoundsModeEXT( + XrSpatialContainerEXT spatialContainer, + const XrSpatialContainerBoundsModeRequestInfoEXT* info); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialContainerBoundsEXT( + XrSpatialContainerEXT spatialContainer, + const XrSpatialContainerBoundsGetInfoEXT* getInfo, + XrSpatialContainerBoundsEXT* bounds); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetSpatialContainerStateEXT( + XrSpatialContainerEXT spatialContainer, + const XrSpatialContainerStateGetInfoEXT* getInfo, + XrSpatialContainerStateEXT* state); + +XRAPI_ATTR XrResult XRAPI_CALL xrEnumerateSupportedSpatialContainerGraphicsPresentationsEXT( + XrInstance instance, + XrSystemId systemId, + uint32_t graphicsPresentationCapacityInput, + uint32_t* graphicsPresentationCountOutput, + XrSpatialContainerGraphicsPresentationEXT* graphicsPresentations); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_EXT_spatial_container_self_rendering is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_spatial_container_self_rendering 1 +#define XR_EXT_spatial_container_self_rendering_SPEC_VERSION 1 +#define XR_EXT_SPATIAL_CONTAINER_SELF_RENDERING_EXTENSION_NAME "XR_EXT_spatial_container_self_rendering" +typedef struct XrSpatialContainerViewLocateInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrViewConfigurationType viewConfigurationType; + XrSpace space; + XrSpatialContainerEXT spatialContainer; +} XrSpatialContainerViewLocateInfoEXT; + +typedef struct XrSpatialContainerViewsLocateInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrTime displayTime; + uint32_t viewLocateInfoCount; + const XrSpatialContainerViewLocateInfoEXT* viewLocateInfos; +} XrSpatialContainerViewsLocateInfoEXT; + +typedef struct XrSpatialContainerViewStateEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrViewStateFlags viewStateFlags; + XrViewConfigurationType viewConfigurationType; + XrBool32 shouldSubmitLayers; + XrExtent2Di recommendedImageExtent; +} XrSpatialContainerViewStateEXT; + +typedef struct XrSpatialContainerLayerEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialContainerEXT spatialContainer; + XrBool32 retainPreviousSubmission; + uint32_t layerCount; + const XrCompositionLayerBaseHeader* const* layers; +} XrSpatialContainerLayerEXT; + +// XrSpatialContainerLayerFrameEndInfoEXT extends XrFrameEndInfo +typedef struct XrSpatialContainerLayerFrameEndInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t containerLayerCount; + const XrSpatialContainerLayerEXT* containerLayers; +} XrSpatialContainerLayerFrameEndInfoEXT; + +typedef struct XrSpatialContainerBeginInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialContainerEXT spatialContainer; + XrViewConfigurationType primaryViewConfigurationType; +} XrSpatialContainerBeginInfoEXT; + +typedef struct XrSpatialContainerEndInfoEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialContainerEXT spatialContainer; +} XrSpatialContainerEndInfoEXT; + +// XrSpatialContainerCompositionLayerViewConfigurationEXT extends XrCompositionLayerProjection +typedef struct XrSpatialContainerCompositionLayerViewConfigurationEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrViewConfigurationType viewConfigurationType; +} XrSpatialContainerCompositionLayerViewConfigurationEXT; + +// XrSpatialContainerLayerVolumeClippingEXT extends XrSpatialContainerLayerEXT +typedef struct XrSpatialContainerLayerVolumeClippingEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpatialContainerVolumeClippingEXT volumeClipping; +} XrSpatialContainerLayerVolumeClippingEXT; + +typedef XrResult (XRAPI_PTR *PFN_xrBeginSpatialContainerRenderingEXT)(XrSession session, const XrSpatialContainerBeginInfoEXT* beginInfo); +typedef XrResult (XRAPI_PTR *PFN_xrEndSpatialContainerRenderingEXT)(XrSession session, const XrSpatialContainerEndInfoEXT* endInfo); +typedef XrResult (XRAPI_PTR *PFN_xrLocateSpatialContainerViewsEXT)(XrSession session, const XrSpatialContainerViewsLocateInfoEXT* locateInfo, uint32_t viewStateCount, XrSpatialContainerViewStateEXT* viewStates, uint32_t viewCount, XrView* views); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrBeginSpatialContainerRenderingEXT( + XrSession session, + const XrSpatialContainerBeginInfoEXT* beginInfo); + +XRAPI_ATTR XrResult XRAPI_CALL xrEndSpatialContainerRenderingEXT( + XrSession session, + const XrSpatialContainerEndInfoEXT* endInfo); + +XRAPI_ATTR XrResult XRAPI_CALL xrLocateSpatialContainerViewsEXT( + XrSession session, + const XrSpatialContainerViewsLocateInfoEXT* locateInfo, + uint32_t viewStateCount, + XrSpatialContainerViewStateEXT* viewStates, + uint32_t viewCount, + XrView* views); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + + +// XR_EXT_interaction_profile_battery_state_display is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_interaction_profile_battery_state_display 1 +#define XR_EXT_interaction_profile_battery_state_display_SPEC_VERSION 1 +#define XR_EXT_INTERACTION_PROFILE_BATTERY_STATE_DISPLAY_EXTENSION_NAME "XR_EXT_interaction_profile_battery_state_display" +typedef XrFlags64 XrBatteryStateDisplayStateFlagsEXT; + +// Flag bits for XrBatteryStateDisplayStateFlagsEXT +static const XrBatteryStateDisplayStateFlagsEXT XR_BATTERY_STATE_DISPLAY_STATE_VALID_BIT_EXT = 0x00000001; +static const XrBatteryStateDisplayStateFlagsEXT XR_BATTERY_STATE_DISPLAY_STATE_CHARGING_BIT_EXT = 0x00000002; +static const XrBatteryStateDisplayStateFlagsEXT XR_BATTERY_STATE_DISPLAY_STATE_PLUGGED_IN_BIT_EXT = 0x00000004; +static const XrBatteryStateDisplayStateFlagsEXT XR_BATTERY_STATE_DISPLAY_STATE_NO_BATTERY_BIT_EXT = 0x00000008; + +// XrBatteryStateDisplayEXT extends XrInteractionProfileState +typedef struct XrBatteryStateDisplayEXT { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBatteryStateDisplayStateFlagsEXT stateFlags; + float batteryLevel; +} XrBatteryStateDisplayEXT; + + + +// XR_EXT_loader_init_properties is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_loader_init_properties 1 +#define XR_EXT_loader_init_properties_SPEC_VERSION 1 +#define XR_EXT_LOADER_INIT_PROPERTIES_EXTENSION_NAME "XR_EXT_loader_init_properties" +typedef struct XrLoaderInitPropertyValueEXT { + const char* name; + const char* value; +} XrLoaderInitPropertyValueEXT; + +// XrLoaderInitInfoPropertiesEXT extends XrLoaderInitInfoBaseHeaderKHR +typedef struct XrLoaderInitInfoPropertiesEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t propertyValueCount; + const XrLoaderInitPropertyValueEXT* propertyValues; +} XrLoaderInitInfoPropertiesEXT; + + + +// XR_EXT_view_configuration_views_change is a preprocessor guard. Do not pass it to API calls. +#define XR_EXT_view_configuration_views_change 1 +#define XR_EXT_view_configuration_views_change_SPEC_VERSION 1 +#define XR_EXT_VIEW_CONFIGURATION_VIEWS_CHANGE_EXTENSION_NAME "XR_EXT_view_configuration_views_change" +typedef struct XrEventDataViewConfigurationViewsChangedEXT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSystemId systemId; + XrViewConfigurationType viewConfigurationType; +} XrEventDataViewConfigurationViewsChangedEXT; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/shadps4-arm64-main/externals/openxr-sdk/include/openxr/openxr_loader_negotiation.h b/shadps4-arm64-main/externals/openxr-sdk/include/openxr/openxr_loader_negotiation.h new file mode 100644 index 0000000..110c537 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/include/openxr/openxr_loader_negotiation.h @@ -0,0 +1,141 @@ +#ifndef OPENXR_LOADER_NEGOTIATION_H_ +#define OPENXR_LOADER_NEGOTIATION_H_ 1 + +/* +** Copyright 2017-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 OR MIT +*/ + +/* +** This header is generated from the Khronos OpenXR XML API Registry. +** +*/ + +#include "openxr.h" + +#ifdef __cplusplus +extern "C" { +#endif + + + +// XR_LOADER_VERSION_1_0 is a preprocessor guard. Do not pass it to API calls. +#define XR_LOADER_VERSION_1_0 1 + +#define XR_CURRENT_LOADER_API_LAYER_VERSION 1 + + +#define XR_CURRENT_LOADER_RUNTIME_VERSION 1 + + +#define XR_LOADER_INFO_STRUCT_VERSION 1 + + +#define XR_API_LAYER_INFO_STRUCT_VERSION 1 + + +#define XR_RUNTIME_INFO_STRUCT_VERSION 1 + + +#define XR_API_LAYER_NEXT_INFO_STRUCT_VERSION 1 + + +#define XR_API_LAYER_CREATE_INFO_STRUCT_VERSION 1 + + +#define XR_API_LAYER_MAX_SETTINGS_PATH_SIZE 512 + + +typedef enum XrLoaderInterfaceStructs { + XR_LOADER_INTERFACE_STRUCT_UNINTIALIZED = 0, + XR_LOADER_INTERFACE_STRUCT_LOADER_INFO = 1, + XR_LOADER_INTERFACE_STRUCT_API_LAYER_REQUEST = 2, + XR_LOADER_INTERFACE_STRUCT_RUNTIME_REQUEST = 3, + XR_LOADER_INTERFACE_STRUCT_API_LAYER_CREATE_INFO = 4, + XR_LOADER_INTERFACE_STRUCT_API_LAYER_NEXT_INFO = 5, + XR_LOADER_INTERFACE_STRUCTS_MAX_ENUM = 0x7FFFFFFF +} XrLoaderInterfaceStructs; +typedef XrResult (XRAPI_PTR *PFN_xrGetInstanceProcAddr)(XrInstance instance, const char* name, PFN_xrVoidFunction* function); + +typedef struct XrApiLayerCreateInfo XrApiLayerCreateInfo; +typedef XrResult (XRAPI_PTR *PFN_xrCreateApiLayerInstance)( + const XrInstanceCreateInfo* info, + const XrApiLayerCreateInfo* apiLayerInfo, + XrInstance* instance); + +typedef struct XrApiLayerNextInfo { + XrLoaderInterfaceStructs structType; + uint32_t structVersion; + size_t structSize; + char layerName[XR_MAX_API_LAYER_NAME_SIZE]; + PFN_xrGetInstanceProcAddr nextGetInstanceProcAddr; + PFN_xrCreateApiLayerInstance nextCreateApiLayerInstance; + struct XrApiLayerNextInfo* next; +} XrApiLayerNextInfo; + +typedef struct XrApiLayerCreateInfo { + XrLoaderInterfaceStructs structType; + uint32_t structVersion; + size_t structSize; + void* XR_MAY_ALIAS loaderInstance; + char settings_file_location[XR_API_LAYER_MAX_SETTINGS_PATH_SIZE]; + XrApiLayerNextInfo* nextInfo; +} XrApiLayerCreateInfo; + +typedef struct XrNegotiateApiLayerRequest { + XrLoaderInterfaceStructs structType; + uint32_t structVersion; + size_t structSize; + uint32_t layerInterfaceVersion; + XrVersion layerApiVersion; + PFN_xrGetInstanceProcAddr getInstanceProcAddr; + PFN_xrCreateApiLayerInstance createApiLayerInstance; +} XrNegotiateApiLayerRequest; + +typedef struct XrNegotiateLoaderInfo { + XrLoaderInterfaceStructs structType; + uint32_t structVersion; + size_t structSize; + uint32_t minInterfaceVersion; + uint32_t maxInterfaceVersion; + XrVersion minApiVersion; + XrVersion maxApiVersion; +} XrNegotiateLoaderInfo; + +typedef struct XrNegotiateRuntimeRequest { + XrLoaderInterfaceStructs structType; + uint32_t structVersion; + size_t structSize; + uint32_t runtimeInterfaceVersion; + XrVersion runtimeApiVersion; + PFN_xrGetInstanceProcAddr getInstanceProcAddr; +} XrNegotiateRuntimeRequest; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateApiLayerInstance)(const XrInstanceCreateInfo* info, const XrApiLayerCreateInfo* layerInfo, XrInstance* instance); +typedef XrResult (XRAPI_PTR *PFN_xrNegotiateLoaderRuntimeInterface)(const XrNegotiateLoaderInfo* loaderInfo, XrNegotiateRuntimeRequest* runtimeRequest); +typedef XrResult (XRAPI_PTR *PFN_xrNegotiateLoaderApiLayerInterface)(const XrNegotiateLoaderInfo* loaderInfo, const char* layerName, XrNegotiateApiLayerRequest* apiLayerRequest); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateApiLayerInstance( + const XrInstanceCreateInfo* info, + const XrApiLayerCreateInfo* layerInfo, + XrInstance* instance); + +XRAPI_ATTR XrResult XRAPI_CALL xrNegotiateLoaderRuntimeInterface( + const XrNegotiateLoaderInfo* loaderInfo, + XrNegotiateRuntimeRequest* runtimeRequest); + +XRAPI_ATTR XrResult XRAPI_CALL xrNegotiateLoaderApiLayerInterface( + const XrNegotiateLoaderInfo* loaderInfo, + const char* layerName, + XrNegotiateApiLayerRequest* apiLayerRequest); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/shadps4-arm64-main/externals/openxr-sdk/include/openxr/openxr_platform.h b/shadps4-arm64-main/externals/openxr-sdk/include/openxr/openxr_platform.h new file mode 100644 index 0000000..9de27ad --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/include/openxr/openxr_platform.h @@ -0,0 +1,819 @@ +#ifndef OPENXR_PLATFORM_H_ +#define OPENXR_PLATFORM_H_ 1 + +/* +** Copyright 2017-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 OR MIT +*/ + +/* +** This header is generated from the Khronos OpenXR XML API Registry. +** +*/ + +#include "openxr.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +#ifdef XR_USE_PLATFORM_ANDROID + +// XR_KHR_android_thread_settings is a preprocessor guard. Do not pass it to API calls. +#define XR_KHR_android_thread_settings 1 +#define XR_KHR_android_thread_settings_SPEC_VERSION 6 +#define XR_KHR_ANDROID_THREAD_SETTINGS_EXTENSION_NAME "XR_KHR_android_thread_settings" + +typedef enum XrAndroidThreadTypeKHR { + XR_ANDROID_THREAD_TYPE_APPLICATION_MAIN_KHR = 1, + XR_ANDROID_THREAD_TYPE_APPLICATION_WORKER_KHR = 2, + XR_ANDROID_THREAD_TYPE_RENDERER_MAIN_KHR = 3, + XR_ANDROID_THREAD_TYPE_RENDERER_WORKER_KHR = 4, + XR_ANDROID_THREAD_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} XrAndroidThreadTypeKHR; +typedef XrResult (XRAPI_PTR *PFN_xrSetAndroidApplicationThreadKHR)(XrSession session, XrAndroidThreadTypeKHR threadType, uint32_t threadId); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrSetAndroidApplicationThreadKHR( + XrSession session, + XrAndroidThreadTypeKHR threadType, + uint32_t threadId); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ +#endif /* XR_USE_PLATFORM_ANDROID */ + +#ifdef XR_USE_PLATFORM_ANDROID + +// XR_KHR_android_surface_swapchain is a preprocessor guard. Do not pass it to API calls. +#define XR_KHR_android_surface_swapchain 1 +#define XR_KHR_android_surface_swapchain_SPEC_VERSION 4 +#define XR_KHR_ANDROID_SURFACE_SWAPCHAIN_EXTENSION_NAME "XR_KHR_android_surface_swapchain" +typedef XrResult (XRAPI_PTR *PFN_xrCreateSwapchainAndroidSurfaceKHR)(XrSession session, const XrSwapchainCreateInfo* info, XrSwapchain* swapchain, jobject* surface); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSwapchainAndroidSurfaceKHR( + XrSession session, + const XrSwapchainCreateInfo* info, + XrSwapchain* swapchain, + jobject* surface); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ +#endif /* XR_USE_PLATFORM_ANDROID */ + +#ifdef XR_USE_PLATFORM_ANDROID + +// XR_KHR_android_create_instance is a preprocessor guard. Do not pass it to API calls. +#define XR_KHR_android_create_instance 1 +#define XR_KHR_android_create_instance_SPEC_VERSION 3 +#define XR_KHR_ANDROID_CREATE_INSTANCE_EXTENSION_NAME "XR_KHR_android_create_instance" +// XrInstanceCreateInfoAndroidKHR extends XrInstanceCreateInfo +typedef struct XrInstanceCreateInfoAndroidKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + void* XR_MAY_ALIAS applicationVM; + void* XR_MAY_ALIAS applicationActivity; +} XrInstanceCreateInfoAndroidKHR; + +#endif /* XR_USE_PLATFORM_ANDROID */ + +#ifdef XR_USE_GRAPHICS_API_VULKAN + +// XR_KHR_vulkan_swapchain_format_list is a preprocessor guard. Do not pass it to API calls. +#define XR_KHR_vulkan_swapchain_format_list 1 +#define XR_KHR_vulkan_swapchain_format_list_SPEC_VERSION 5 +#define XR_KHR_VULKAN_SWAPCHAIN_FORMAT_LIST_EXTENSION_NAME "XR_KHR_vulkan_swapchain_format_list" +// XrVulkanSwapchainFormatListCreateInfoKHR extends XrSwapchainCreateInfo +typedef struct XrVulkanSwapchainFormatListCreateInfoKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + uint32_t viewFormatCount; + const VkFormat* viewFormats; +} XrVulkanSwapchainFormatListCreateInfoKHR; + +#endif /* XR_USE_GRAPHICS_API_VULKAN */ + +#ifdef XR_USE_GRAPHICS_API_OPENGL + +// XR_KHR_opengl_enable is a preprocessor guard. Do not pass it to API calls. +#define XR_KHR_opengl_enable 1 +#define XR_KHR_opengl_enable_SPEC_VERSION 12 +#define XR_KHR_OPENGL_ENABLE_EXTENSION_NAME "XR_KHR_opengl_enable" +#ifdef XR_USE_PLATFORM_WIN32 +// XrGraphicsBindingOpenGLWin32KHR extends XrSessionCreateInfo +typedef struct XrGraphicsBindingOpenGLWin32KHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + HDC hDC; + HGLRC hGLRC; +} XrGraphicsBindingOpenGLWin32KHR; +#endif // XR_USE_PLATFORM_WIN32 + +#ifdef XR_USE_PLATFORM_XLIB +// XrGraphicsBindingOpenGLXlibKHR extends XrSessionCreateInfo +typedef struct XrGraphicsBindingOpenGLXlibKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + Display* xDisplay; + uint32_t visualid; + GLXFBConfig glxFBConfig; + GLXDrawable glxDrawable; + GLXContext glxContext; +} XrGraphicsBindingOpenGLXlibKHR; +#endif // XR_USE_PLATFORM_XLIB + +#ifdef XR_USE_PLATFORM_XCB +// XrGraphicsBindingOpenGLXcbKHR extends XrSessionCreateInfo +typedef struct XrGraphicsBindingOpenGLXcbKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + xcb_connection_t* connection; + uint32_t screenNumber; + xcb_glx_fbconfig_t fbconfigid; + xcb_visualid_t visualid; + xcb_glx_drawable_t glxDrawable; + xcb_glx_context_t glxContext; +} XrGraphicsBindingOpenGLXcbKHR; +#endif // XR_USE_PLATFORM_XCB + +#ifdef XR_USE_PLATFORM_WAYLAND +// XrGraphicsBindingOpenGLWaylandKHR extends XrSessionCreateInfo +typedef struct XrGraphicsBindingOpenGLWaylandKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + struct wl_display* display; +} XrGraphicsBindingOpenGLWaylandKHR; +#endif // XR_USE_PLATFORM_WAYLAND + +typedef struct XrSwapchainImageOpenGLKHR { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t image; +} XrSwapchainImageOpenGLKHR; + +typedef struct XrGraphicsRequirementsOpenGLKHR { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrVersion minApiVersionSupported; + XrVersion maxApiVersionSupported; +} XrGraphicsRequirementsOpenGLKHR; + +typedef XrResult (XRAPI_PTR *PFN_xrGetOpenGLGraphicsRequirementsKHR)(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsOpenGLKHR* graphicsRequirements); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetOpenGLGraphicsRequirementsKHR( + XrInstance instance, + XrSystemId systemId, + XrGraphicsRequirementsOpenGLKHR* graphicsRequirements); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ +#endif /* XR_USE_GRAPHICS_API_OPENGL */ + +#ifdef XR_USE_GRAPHICS_API_OPENGL_ES + +// XR_KHR_opengl_es_enable is a preprocessor guard. Do not pass it to API calls. +#define XR_KHR_opengl_es_enable 1 +#define XR_KHR_opengl_es_enable_SPEC_VERSION 10 +#define XR_KHR_OPENGL_ES_ENABLE_EXTENSION_NAME "XR_KHR_opengl_es_enable" +#ifdef XR_USE_PLATFORM_ANDROID +// XrGraphicsBindingOpenGLESAndroidKHR extends XrSessionCreateInfo +typedef struct XrGraphicsBindingOpenGLESAndroidKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + EGLDisplay display; + EGLConfig config; + EGLContext context; +} XrGraphicsBindingOpenGLESAndroidKHR; +#endif // XR_USE_PLATFORM_ANDROID + +typedef struct XrSwapchainImageOpenGLESKHR { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t image; +} XrSwapchainImageOpenGLESKHR; + +typedef struct XrGraphicsRequirementsOpenGLESKHR { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrVersion minApiVersionSupported; + XrVersion maxApiVersionSupported; +} XrGraphicsRequirementsOpenGLESKHR; + +typedef XrResult (XRAPI_PTR *PFN_xrGetOpenGLESGraphicsRequirementsKHR)(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsOpenGLESKHR* graphicsRequirements); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetOpenGLESGraphicsRequirementsKHR( + XrInstance instance, + XrSystemId systemId, + XrGraphicsRequirementsOpenGLESKHR* graphicsRequirements); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ +#endif /* XR_USE_GRAPHICS_API_OPENGL_ES */ + +#ifdef XR_USE_GRAPHICS_API_VULKAN + +// XR_KHR_vulkan_enable is a preprocessor guard. Do not pass it to API calls. +#define XR_KHR_vulkan_enable 1 +#define XR_KHR_vulkan_enable_SPEC_VERSION 10 +#define XR_KHR_VULKAN_ENABLE_EXTENSION_NAME "XR_KHR_vulkan_enable" +// XrGraphicsBindingVulkanKHR extends XrSessionCreateInfo +typedef struct XrGraphicsBindingVulkanKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + VkInstance instance; + VkPhysicalDevice physicalDevice; + VkDevice device; + uint32_t queueFamilyIndex; + uint32_t queueIndex; +} XrGraphicsBindingVulkanKHR; + +typedef struct XrSwapchainImageVulkanKHR { + XrStructureType type; + void* XR_MAY_ALIAS next; + VkImage image; +} XrSwapchainImageVulkanKHR; + +typedef struct XrGraphicsRequirementsVulkanKHR { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrVersion minApiVersionSupported; + XrVersion maxApiVersionSupported; +} XrGraphicsRequirementsVulkanKHR; + +typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanInstanceExtensionsKHR)(XrInstance instance, XrSystemId systemId, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, char* buffer); +typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanDeviceExtensionsKHR)(XrInstance instance, XrSystemId systemId, uint32_t bufferCapacityInput, uint32_t* bufferCountOutput, char* buffer); +typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanGraphicsDeviceKHR)(XrInstance instance, XrSystemId systemId, VkInstance vkInstance, VkPhysicalDevice* vkPhysicalDevice); +typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanGraphicsRequirementsKHR)(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsVulkanKHR* graphicsRequirements); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetVulkanInstanceExtensionsKHR( + XrInstance instance, + XrSystemId systemId, + uint32_t bufferCapacityInput, + uint32_t* bufferCountOutput, + char* buffer); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetVulkanDeviceExtensionsKHR( + XrInstance instance, + XrSystemId systemId, + uint32_t bufferCapacityInput, + uint32_t* bufferCountOutput, + char* buffer); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetVulkanGraphicsDeviceKHR( + XrInstance instance, + XrSystemId systemId, + VkInstance vkInstance, + VkPhysicalDevice* vkPhysicalDevice); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetVulkanGraphicsRequirementsKHR( + XrInstance instance, + XrSystemId systemId, + XrGraphicsRequirementsVulkanKHR* graphicsRequirements); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ +#endif /* XR_USE_GRAPHICS_API_VULKAN */ + +#ifdef XR_USE_GRAPHICS_API_D3D11 + +// XR_KHR_D3D11_enable is a preprocessor guard. Do not pass it to API calls. +#define XR_KHR_D3D11_enable 1 +#define XR_KHR_D3D11_enable_SPEC_VERSION 11 +#define XR_KHR_D3D11_ENABLE_EXTENSION_NAME "XR_KHR_D3D11_enable" +// XrGraphicsBindingD3D11KHR extends XrSessionCreateInfo +typedef struct XrGraphicsBindingD3D11KHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + ID3D11Device* device; +} XrGraphicsBindingD3D11KHR; + +typedef struct XrSwapchainImageD3D11KHR { + XrStructureType type; + void* XR_MAY_ALIAS next; + ID3D11Texture2D* texture; +} XrSwapchainImageD3D11KHR; + +typedef struct XrGraphicsRequirementsD3D11KHR { + XrStructureType type; + void* XR_MAY_ALIAS next; + LUID adapterLuid; + D3D_FEATURE_LEVEL minFeatureLevel; +} XrGraphicsRequirementsD3D11KHR; + +typedef XrResult (XRAPI_PTR *PFN_xrGetD3D11GraphicsRequirementsKHR)(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsD3D11KHR* graphicsRequirements); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetD3D11GraphicsRequirementsKHR( + XrInstance instance, + XrSystemId systemId, + XrGraphicsRequirementsD3D11KHR* graphicsRequirements); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ +#endif /* XR_USE_GRAPHICS_API_D3D11 */ + +#ifdef XR_USE_GRAPHICS_API_D3D12 + +// XR_KHR_D3D12_enable is a preprocessor guard. Do not pass it to API calls. +#define XR_KHR_D3D12_enable 1 +#define XR_KHR_D3D12_enable_SPEC_VERSION 11 +#define XR_KHR_D3D12_ENABLE_EXTENSION_NAME "XR_KHR_D3D12_enable" +// XrGraphicsBindingD3D12KHR extends XrSessionCreateInfo +typedef struct XrGraphicsBindingD3D12KHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + ID3D12Device* device; + ID3D12CommandQueue* queue; +} XrGraphicsBindingD3D12KHR; + +typedef struct XrSwapchainImageD3D12KHR { + XrStructureType type; + void* XR_MAY_ALIAS next; + ID3D12Resource* texture; +} XrSwapchainImageD3D12KHR; + +typedef struct XrGraphicsRequirementsD3D12KHR { + XrStructureType type; + void* XR_MAY_ALIAS next; + LUID adapterLuid; + D3D_FEATURE_LEVEL minFeatureLevel; +} XrGraphicsRequirementsD3D12KHR; + +typedef XrResult (XRAPI_PTR *PFN_xrGetD3D12GraphicsRequirementsKHR)(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsD3D12KHR* graphicsRequirements); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetD3D12GraphicsRequirementsKHR( + XrInstance instance, + XrSystemId systemId, + XrGraphicsRequirementsD3D12KHR* graphicsRequirements); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ +#endif /* XR_USE_GRAPHICS_API_D3D12 */ + +#ifdef XR_USE_GRAPHICS_API_METAL + +// XR_KHR_metal_enable is a preprocessor guard. Do not pass it to API calls. +#define XR_KHR_metal_enable 1 +#define XR_KHR_metal_enable_SPEC_VERSION 3 +#define XR_KHR_METAL_ENABLE_EXTENSION_NAME "XR_KHR_metal_enable" +// XrGraphicsBindingMetalKHR extends XrSessionCreateInfo +typedef struct XrGraphicsBindingMetalKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + void* XR_MAY_ALIAS commandQueue; +} XrGraphicsBindingMetalKHR; + +typedef struct XrSwapchainImageMetalKHR { + XrStructureType type; + void* XR_MAY_ALIAS next; + void* XR_MAY_ALIAS texture; +} XrSwapchainImageMetalKHR; + +typedef struct XrGraphicsRequirementsMetalKHR { + XrStructureType type; + void* XR_MAY_ALIAS next; + void* XR_MAY_ALIAS metalDevice; +} XrGraphicsRequirementsMetalKHR; + +typedef XrResult (XRAPI_PTR *PFN_xrGetMetalGraphicsRequirementsKHR)(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsMetalKHR* graphicsRequirements); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetMetalGraphicsRequirementsKHR( + XrInstance instance, + XrSystemId systemId, + XrGraphicsRequirementsMetalKHR* graphicsRequirements); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ +#endif /* XR_USE_GRAPHICS_API_METAL */ + +#ifdef XR_USE_PLATFORM_WIN32 + +// XR_KHR_win32_convert_performance_counter_time is a preprocessor guard. Do not pass it to API calls. +#define XR_KHR_win32_convert_performance_counter_time 1 +#define XR_KHR_win32_convert_performance_counter_time_SPEC_VERSION 1 +#define XR_KHR_WIN32_CONVERT_PERFORMANCE_COUNTER_TIME_EXTENSION_NAME "XR_KHR_win32_convert_performance_counter_time" +typedef XrResult (XRAPI_PTR *PFN_xrConvertWin32PerformanceCounterToTimeKHR)(XrInstance instance, const LARGE_INTEGER* performanceCounter, XrTime* time); +typedef XrResult (XRAPI_PTR *PFN_xrConvertTimeToWin32PerformanceCounterKHR)(XrInstance instance, XrTime time, LARGE_INTEGER* performanceCounter); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrConvertWin32PerformanceCounterToTimeKHR( + XrInstance instance, + const LARGE_INTEGER* performanceCounter, + XrTime* time); + +XRAPI_ATTR XrResult XRAPI_CALL xrConvertTimeToWin32PerformanceCounterKHR( + XrInstance instance, + XrTime time, + LARGE_INTEGER* performanceCounter); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ +#endif /* XR_USE_PLATFORM_WIN32 */ + +#ifdef XR_USE_TIMESPEC + +// XR_KHR_convert_timespec_time is a preprocessor guard. Do not pass it to API calls. +#define XR_KHR_convert_timespec_time 1 +#define XR_KHR_convert_timespec_time_SPEC_VERSION 1 +#define XR_KHR_CONVERT_TIMESPEC_TIME_EXTENSION_NAME "XR_KHR_convert_timespec_time" +typedef XrResult (XRAPI_PTR *PFN_xrConvertTimespecTimeToTimeKHR)(XrInstance instance, const struct timespec* timespecTime, XrTime* time); +typedef XrResult (XRAPI_PTR *PFN_xrConvertTimeToTimespecTimeKHR)(XrInstance instance, XrTime time, struct timespec* timespecTime); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrConvertTimespecTimeToTimeKHR( + XrInstance instance, + const struct timespec* timespecTime, + XrTime* time); + +XRAPI_ATTR XrResult XRAPI_CALL xrConvertTimeToTimespecTimeKHR( + XrInstance instance, + XrTime time, + struct timespec* timespecTime); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ +#endif /* XR_USE_TIMESPEC */ + +#ifdef XR_USE_PLATFORM_ANDROID + +// XR_KHR_loader_init_android is a preprocessor guard. Do not pass it to API calls. +#define XR_KHR_loader_init_android 1 +#define XR_KHR_loader_init_android_SPEC_VERSION 1 +#define XR_KHR_LOADER_INIT_ANDROID_EXTENSION_NAME "XR_KHR_loader_init_android" +typedef struct XrLoaderInitInfoAndroidKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + void* XR_MAY_ALIAS applicationVM; + void* XR_MAY_ALIAS applicationContext; +} XrLoaderInitInfoAndroidKHR; + +#endif /* XR_USE_PLATFORM_ANDROID */ + +#ifdef XR_USE_GRAPHICS_API_VULKAN + +// XR_KHR_vulkan_enable2 is a preprocessor guard. Do not pass it to API calls. +#define XR_KHR_vulkan_enable2 1 +#define XR_KHR_vulkan_enable2_SPEC_VERSION 4 +#define XR_KHR_VULKAN_ENABLE2_EXTENSION_NAME "XR_KHR_vulkan_enable2" +typedef XrFlags64 XrVulkanInstanceCreateFlagsKHR; + +// Flag bits for XrVulkanInstanceCreateFlagsKHR + +typedef XrFlags64 XrVulkanDeviceCreateFlagsKHR; + +// Flag bits for XrVulkanDeviceCreateFlagsKHR + +typedef struct XrVulkanInstanceCreateInfoKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSystemId systemId; + XrVulkanInstanceCreateFlagsKHR createFlags; + PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr; + const VkInstanceCreateInfo* vulkanCreateInfo; + const VkAllocationCallbacks* vulkanAllocator; +} XrVulkanInstanceCreateInfoKHR; + +typedef struct XrVulkanDeviceCreateInfoKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSystemId systemId; + XrVulkanDeviceCreateFlagsKHR createFlags; + PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr; + VkPhysicalDevice vulkanPhysicalDevice; + const VkDeviceCreateInfo* vulkanCreateInfo; + const VkAllocationCallbacks* vulkanAllocator; +} XrVulkanDeviceCreateInfoKHR; + +typedef XrGraphicsBindingVulkanKHR XrGraphicsBindingVulkan2KHR; + +typedef struct XrVulkanGraphicsDeviceGetInfoKHR { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSystemId systemId; + VkInstance vulkanInstance; +} XrVulkanGraphicsDeviceGetInfoKHR; + +typedef XrSwapchainImageVulkanKHR XrSwapchainImageVulkan2KHR; + +typedef XrGraphicsRequirementsVulkanKHR XrGraphicsRequirementsVulkan2KHR; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateVulkanInstanceKHR)(XrInstance instance, const XrVulkanInstanceCreateInfoKHR* createInfo, VkInstance* vulkanInstance, VkResult* vulkanResult); +typedef XrResult (XRAPI_PTR *PFN_xrCreateVulkanDeviceKHR)(XrInstance instance, const XrVulkanDeviceCreateInfoKHR* createInfo, VkDevice* vulkanDevice, VkResult* vulkanResult); +typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanGraphicsDevice2KHR)(XrInstance instance, const XrVulkanGraphicsDeviceGetInfoKHR* getInfo, VkPhysicalDevice* vulkanPhysicalDevice); +typedef XrResult (XRAPI_PTR *PFN_xrGetVulkanGraphicsRequirements2KHR)(XrInstance instance, XrSystemId systemId, XrGraphicsRequirementsVulkanKHR* graphicsRequirements); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateVulkanInstanceKHR( + XrInstance instance, + const XrVulkanInstanceCreateInfoKHR* createInfo, + VkInstance* vulkanInstance, + VkResult* vulkanResult); + +XRAPI_ATTR XrResult XRAPI_CALL xrCreateVulkanDeviceKHR( + XrInstance instance, + const XrVulkanDeviceCreateInfoKHR* createInfo, + VkDevice* vulkanDevice, + VkResult* vulkanResult); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetVulkanGraphicsDevice2KHR( + XrInstance instance, + const XrVulkanGraphicsDeviceGetInfoKHR* getInfo, + VkPhysicalDevice* vulkanPhysicalDevice); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetVulkanGraphicsRequirements2KHR( + XrInstance instance, + XrSystemId systemId, + XrGraphicsRequirementsVulkanKHR* graphicsRequirements); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ +#endif /* XR_USE_GRAPHICS_API_VULKAN */ + +#ifdef XR_USE_PLATFORM_EGL + +// XR_MNDX_egl_enable is a preprocessor guard. Do not pass it to API calls. +#define XR_MNDX_egl_enable 1 +#define XR_MNDX_egl_enable_SPEC_VERSION 2 +#define XR_MNDX_EGL_ENABLE_EXTENSION_NAME "XR_MNDX_egl_enable" +typedef PFN_xrVoidFunction (*PFN_xrEglGetProcAddressMNDX)(const char *name); +// XrGraphicsBindingEGLMNDX extends XrSessionCreateInfo +typedef struct XrGraphicsBindingEGLMNDX { + XrStructureType type; + const void* XR_MAY_ALIAS next; + PFN_xrEglGetProcAddressMNDX getProcAddress; + EGLDisplay display; + EGLConfig config; + EGLContext context; +} XrGraphicsBindingEGLMNDX; + +#endif /* XR_USE_PLATFORM_EGL */ + +#ifdef XR_USE_PLATFORM_WIN32 + +// XR_MSFT_perception_anchor_interop is a preprocessor guard. Do not pass it to API calls. +#define XR_MSFT_perception_anchor_interop 1 +#define XR_MSFT_perception_anchor_interop_SPEC_VERSION 1 +#define XR_MSFT_PERCEPTION_ANCHOR_INTEROP_EXTENSION_NAME "XR_MSFT_perception_anchor_interop" +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpatialAnchorFromPerceptionAnchorMSFT)(XrSession session, IUnknown* perceptionAnchor, XrSpatialAnchorMSFT* anchor); +typedef XrResult (XRAPI_PTR *PFN_xrTryGetPerceptionAnchorFromSpatialAnchorMSFT)(XrSession session, XrSpatialAnchorMSFT anchor, IUnknown** perceptionAnchor); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpatialAnchorFromPerceptionAnchorMSFT( + XrSession session, + IUnknown* perceptionAnchor, + XrSpatialAnchorMSFT* anchor); + +XRAPI_ATTR XrResult XRAPI_CALL xrTryGetPerceptionAnchorFromSpatialAnchorMSFT( + XrSession session, + XrSpatialAnchorMSFT anchor, + IUnknown** perceptionAnchor); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ +#endif /* XR_USE_PLATFORM_WIN32 */ + +#ifdef XR_USE_PLATFORM_WIN32 + +// XR_MSFT_holographic_window_attachment is a preprocessor guard. Do not pass it to API calls. +#define XR_MSFT_holographic_window_attachment 1 +#define XR_MSFT_holographic_window_attachment_SPEC_VERSION 1 +#define XR_MSFT_HOLOGRAPHIC_WINDOW_ATTACHMENT_EXTENSION_NAME "XR_MSFT_holographic_window_attachment" +#ifdef XR_USE_PLATFORM_WIN32 +// XrHolographicWindowAttachmentMSFT extends XrSessionCreateInfo +typedef struct XrHolographicWindowAttachmentMSFT { + XrStructureType type; + const void* XR_MAY_ALIAS next; + IUnknown* holographicSpace; + IUnknown* coreWindow; +} XrHolographicWindowAttachmentMSFT; +#endif // XR_USE_PLATFORM_WIN32 + +#endif /* XR_USE_PLATFORM_WIN32 */ + +#ifdef XR_USE_PLATFORM_ANDROID + +// XR_FB_android_surface_swapchain_create is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_android_surface_swapchain_create 1 +#define XR_FB_android_surface_swapchain_create_SPEC_VERSION 1 +#define XR_FB_ANDROID_SURFACE_SWAPCHAIN_CREATE_EXTENSION_NAME "XR_FB_android_surface_swapchain_create" +typedef XrFlags64 XrAndroidSurfaceSwapchainFlagsFB; + +// Flag bits for XrAndroidSurfaceSwapchainFlagsFB +static const XrAndroidSurfaceSwapchainFlagsFB XR_ANDROID_SURFACE_SWAPCHAIN_SYNCHRONOUS_BIT_FB = 0x00000001; +static const XrAndroidSurfaceSwapchainFlagsFB XR_ANDROID_SURFACE_SWAPCHAIN_USE_TIMESTAMPS_BIT_FB = 0x00000002; + +#ifdef XR_USE_PLATFORM_ANDROID +// XrAndroidSurfaceSwapchainCreateInfoFB extends XrSwapchainCreateInfo +typedef struct XrAndroidSurfaceSwapchainCreateInfoFB { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrAndroidSurfaceSwapchainFlagsFB createFlags; +} XrAndroidSurfaceSwapchainCreateInfoFB; +#endif // XR_USE_PLATFORM_ANDROID + +#endif /* XR_USE_PLATFORM_ANDROID */ + +#ifdef XR_USE_PLATFORM_ML + +// XR_ML_compat is a preprocessor guard. Do not pass it to API calls. +#define XR_ML_compat 1 +#define XR_ML_compat_SPEC_VERSION 1 +#define XR_ML_COMPAT_EXTENSION_NAME "XR_ML_compat" +typedef struct XrCoordinateSpaceCreateInfoML { + XrStructureType type; + const void* XR_MAY_ALIAS next; + MLCoordinateFrameUID cfuid; + XrPosef poseInCoordinateSpace; +} XrCoordinateSpaceCreateInfoML; + +typedef XrResult (XRAPI_PTR *PFN_xrCreateSpaceFromCoordinateFrameUIDML)(XrSession session, const XrCoordinateSpaceCreateInfoML *createInfo, XrSpace* space); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrCreateSpaceFromCoordinateFrameUIDML( + XrSession session, + const XrCoordinateSpaceCreateInfoML * createInfo, + XrSpace* space); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ +#endif /* XR_USE_PLATFORM_ML */ + +#ifdef XR_USE_PLATFORM_WIN32 + +// XR_OCULUS_audio_device_guid is a preprocessor guard. Do not pass it to API calls. +#define XR_OCULUS_audio_device_guid 1 +#define XR_OCULUS_audio_device_guid_SPEC_VERSION 1 +#define XR_OCULUS_AUDIO_DEVICE_GUID_EXTENSION_NAME "XR_OCULUS_audio_device_guid" +#define XR_MAX_AUDIO_DEVICE_STR_SIZE_OCULUS 128 +typedef XrResult (XRAPI_PTR *PFN_xrGetAudioOutputDeviceGuidOculus)(XrInstance instance, wchar_t buffer[XR_MAX_AUDIO_DEVICE_STR_SIZE_OCULUS]); +typedef XrResult (XRAPI_PTR *PFN_xrGetAudioInputDeviceGuidOculus)(XrInstance instance, wchar_t buffer[XR_MAX_AUDIO_DEVICE_STR_SIZE_OCULUS]); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrGetAudioOutputDeviceGuidOculus( + XrInstance instance, + wchar_t buffer[XR_MAX_AUDIO_DEVICE_STR_SIZE_OCULUS]); + +XRAPI_ATTR XrResult XRAPI_CALL xrGetAudioInputDeviceGuidOculus( + XrInstance instance, + wchar_t buffer[XR_MAX_AUDIO_DEVICE_STR_SIZE_OCULUS]); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ +#endif /* XR_USE_PLATFORM_WIN32 */ + +#ifdef XR_USE_GRAPHICS_API_VULKAN + +// XR_FB_foveation_vulkan is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_foveation_vulkan 1 +#define XR_FB_foveation_vulkan_SPEC_VERSION 1 +#define XR_FB_FOVEATION_VULKAN_EXTENSION_NAME "XR_FB_foveation_vulkan" +// XrSwapchainImageFoveationVulkanFB extends XrSwapchainImageVulkanKHR +typedef struct XrSwapchainImageFoveationVulkanFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + VkImage image; + uint32_t width; + uint32_t height; +} XrSwapchainImageFoveationVulkanFB; + +#endif /* XR_USE_GRAPHICS_API_VULKAN */ + +#ifdef XR_USE_PLATFORM_ANDROID + +// XR_FB_swapchain_update_state_android_surface is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_swapchain_update_state_android_surface 1 +#define XR_FB_swapchain_update_state_android_surface_SPEC_VERSION 1 +#define XR_FB_SWAPCHAIN_UPDATE_STATE_ANDROID_SURFACE_EXTENSION_NAME "XR_FB_swapchain_update_state_android_surface" +#ifdef XR_USE_PLATFORM_ANDROID +typedef struct XrSwapchainStateAndroidSurfaceDimensionsFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + uint32_t width; + uint32_t height; +} XrSwapchainStateAndroidSurfaceDimensionsFB; +#endif // XR_USE_PLATFORM_ANDROID + +#endif /* XR_USE_PLATFORM_ANDROID */ + +#ifdef XR_USE_GRAPHICS_API_OPENGL_ES + +// XR_FB_swapchain_update_state_opengl_es is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_swapchain_update_state_opengl_es 1 +#define XR_FB_swapchain_update_state_opengl_es_SPEC_VERSION 1 +#define XR_FB_SWAPCHAIN_UPDATE_STATE_OPENGL_ES_EXTENSION_NAME "XR_FB_swapchain_update_state_opengl_es" +#ifdef XR_USE_GRAPHICS_API_OPENGL_ES +typedef struct XrSwapchainStateSamplerOpenGLESFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + EGLenum minFilter; + EGLenum magFilter; + EGLenum wrapModeS; + EGLenum wrapModeT; + EGLenum swizzleRed; + EGLenum swizzleGreen; + EGLenum swizzleBlue; + EGLenum swizzleAlpha; + float maxAnisotropy; + XrColor4f borderColor; +} XrSwapchainStateSamplerOpenGLESFB; +#endif // XR_USE_GRAPHICS_API_OPENGL_ES + +#endif /* XR_USE_GRAPHICS_API_OPENGL_ES */ + +#ifdef XR_USE_GRAPHICS_API_VULKAN + +// XR_FB_swapchain_update_state_vulkan is a preprocessor guard. Do not pass it to API calls. +#define XR_FB_swapchain_update_state_vulkan 1 +#define XR_FB_swapchain_update_state_vulkan_SPEC_VERSION 1 +#define XR_FB_SWAPCHAIN_UPDATE_STATE_VULKAN_EXTENSION_NAME "XR_FB_swapchain_update_state_vulkan" +#ifdef XR_USE_GRAPHICS_API_VULKAN +typedef struct XrSwapchainStateSamplerVulkanFB { + XrStructureType type; + void* XR_MAY_ALIAS next; + VkFilter minFilter; + VkFilter magFilter; + VkSamplerMipmapMode mipmapMode; + VkSamplerAddressMode wrapModeS; + VkSamplerAddressMode wrapModeT; + VkComponentSwizzle swizzleRed; + VkComponentSwizzle swizzleGreen; + VkComponentSwizzle swizzleBlue; + VkComponentSwizzle swizzleAlpha; + float maxAnisotropy; + XrColor4f borderColor; +} XrSwapchainStateSamplerVulkanFB; +#endif // XR_USE_GRAPHICS_API_VULKAN + +#endif /* XR_USE_GRAPHICS_API_VULKAN */ + +#ifdef XR_USE_GRAPHICS_API_VULKAN + +// XR_META_vulkan_swapchain_create_info is a preprocessor guard. Do not pass it to API calls. +#define XR_META_vulkan_swapchain_create_info 1 +#define XR_META_vulkan_swapchain_create_info_SPEC_VERSION 1 +#define XR_META_VULKAN_SWAPCHAIN_CREATE_INFO_EXTENSION_NAME "XR_META_vulkan_swapchain_create_info" +// XrVulkanSwapchainCreateInfoMETA extends XrSwapchainCreateInfo +typedef struct XrVulkanSwapchainCreateInfoMETA { + XrStructureType type; + const void* XR_MAY_ALIAS next; + VkImageCreateFlags additionalCreateFlags; + VkImageUsageFlags additionalUsageFlags; +} XrVulkanSwapchainCreateInfoMETA; + +#endif /* XR_USE_GRAPHICS_API_VULKAN */ + +#ifdef XR_USE_PLATFORM_ANDROID + +// XR_ANDROID_anchor_sharing_export is a preprocessor guard. Do not pass it to API calls. +#define XR_ANDROID_anchor_sharing_export 1 +#define XR_ANDROID_anchor_sharing_export_SPEC_VERSION 1 +#define XR_ANDROID_ANCHOR_SHARING_EXPORT_EXTENSION_NAME "XR_ANDROID_anchor_sharing_export" +typedef struct XrAnchorSharingInfoANDROID { + XrStructureType type; + const void* XR_MAY_ALIAS next; + XrSpace anchor; +} XrAnchorSharingInfoANDROID; + +typedef struct XrAnchorSharingTokenANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + struct AIBinder* token; +} XrAnchorSharingTokenANDROID; + +// XrSystemAnchorSharingExportPropertiesANDROID extends XrSystemProperties +typedef struct XrSystemAnchorSharingExportPropertiesANDROID { + XrStructureType type; + void* XR_MAY_ALIAS next; + XrBool32 supportsAnchorSharingExport; +} XrSystemAnchorSharingExportPropertiesANDROID; + +typedef XrResult (XRAPI_PTR *PFN_xrShareAnchorANDROID)(XrSession session, const XrAnchorSharingInfoANDROID* sharingInfo, XrAnchorSharingTokenANDROID* anchorToken); +typedef XrResult (XRAPI_PTR *PFN_xrUnshareAnchorANDROID)(XrSession session, XrSpace anchor); + +#ifndef XR_NO_PROTOTYPES +#ifdef XR_EXTENSION_PROTOTYPES +XRAPI_ATTR XrResult XRAPI_CALL xrShareAnchorANDROID( + XrSession session, + const XrAnchorSharingInfoANDROID* sharingInfo, + XrAnchorSharingTokenANDROID* anchorToken); + +XRAPI_ATTR XrResult XRAPI_CALL xrUnshareAnchorANDROID( + XrSession session, + XrSpace anchor); +#endif /* XR_EXTENSION_PROTOTYPES */ +#endif /* !XR_NO_PROTOTYPES */ +#endif /* XR_USE_PLATFORM_ANDROID */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/shadps4-arm64-main/externals/openxr-sdk/include/openxr/openxr_platform_defines.h b/shadps4-arm64-main/externals/openxr-sdk/include/openxr/openxr_platform_defines.h new file mode 100644 index 0000000..79c5b2c --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/include/openxr/openxr_platform_defines.h @@ -0,0 +1,114 @@ +/* +** Copyright (c) 2017-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 OR MIT +*/ + +#ifndef OPENXR_PLATFORM_DEFINES_H_ +#define OPENXR_PLATFORM_DEFINES_H_ 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* Platform-specific calling convention macros. + * + * Platforms should define these so that OpenXR clients call OpenXR functions + * with the same calling conventions that the OpenXR implementation expects. + * + * XRAPI_ATTR - Placed before the return type in function declarations. + * Useful for C++11 and GCC/Clang-style function attribute syntax. + * XRAPI_CALL - Placed after the return type in function declarations. + * Useful for MSVC-style calling convention syntax. + * XRAPI_PTR - Placed between the '(' and '*' in function pointer types. + * + * Function declaration: XRAPI_ATTR void XRAPI_CALL xrFunction(void); + * Function pointer type: typedef void (XRAPI_PTR *PFN_xrFunction)(void); + */ +#if defined(_WIN32) +#define XRAPI_ATTR +// On Windows, functions use the stdcall convention +#define XRAPI_CALL __stdcall +#define XRAPI_PTR XRAPI_CALL +#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7 +#error "API not supported for the 'armeabi' NDK ABI" +#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE) +// On Android 32-bit ARM targets, functions use the "hardfloat" +// calling convention, i.e. float parameters are passed in registers. This +// is true even if the rest of the application passes floats on the stack, +// as it does by default when compiling for the armeabi-v7a NDK ABI. +#define XRAPI_ATTR __attribute__((pcs("aapcs-vfp"))) +#define XRAPI_CALL +#define XRAPI_PTR XRAPI_ATTR +#else +// On other platforms, use the default calling convention +#define XRAPI_ATTR +#define XRAPI_CALL +#define XRAPI_PTR +#endif + +#include <stddef.h> + +#if !defined(XR_NO_STDINT_H) +#if defined(_MSC_VER) && (_MSC_VER < 1600) +typedef signed __int8 int8_t; +typedef unsigned __int8 uint8_t; +typedef signed __int16 int16_t; +typedef unsigned __int16 uint16_t; +typedef signed __int32 int32_t; +typedef unsigned __int32 uint32_t; +typedef signed __int64 int64_t; +typedef unsigned __int64 uint64_t; +#else +#include <stdint.h> +#endif +#endif // !defined( XR_NO_STDINT_H ) + +// XR_PTR_SIZE (in bytes) +#if (defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined(_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)) +#define XR_PTR_SIZE 8 +#else +#define XR_PTR_SIZE 4 +#endif + +// Needed so we can use clang __has_feature portably. +#if !defined(XR_COMPILER_HAS_FEATURE) +#if defined(__clang__) +#define XR_COMPILER_HAS_FEATURE(x) __has_feature(x) +#else +#define XR_COMPILER_HAS_FEATURE(x) 0 +#endif +#endif + +// Identifies if the current compiler has C++11 support enabled. +// Does not by itself identify if any given C++11 feature is present. +#if !defined(XR_CPP11_ENABLED) && defined(__cplusplus) +#if defined(__GNUC__) && defined(__GXX_EXPERIMENTAL_CXX0X__) +#define XR_CPP11_ENABLED 1 +#elif defined(_MSC_VER) && (_MSC_VER >= 1600) +#define XR_CPP11_ENABLED 1 +#elif (__cplusplus >= 201103L) // 201103 is the first C++11 version. +#define XR_CPP11_ENABLED 1 +#endif +#endif + +// Identifies if the current compiler supports C++11 nullptr. +#if !defined(XR_CPP_NULLPTR_SUPPORTED) +#if defined(XR_CPP11_ENABLED) && \ + ((defined(__clang__) && XR_COMPILER_HAS_FEATURE(cxx_nullptr)) || \ + (defined(__GNUC__) && (((__GNUC__ * 1000) + __GNUC_MINOR__) >= 4006)) || \ + (defined(_MSC_VER) && (_MSC_VER >= 1600)) || \ + (defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 403))) +#define XR_CPP_NULLPTR_SUPPORTED 1 +#endif +#endif + +#if !defined(XR_CPP_NULLPTR_SUPPORTED) +#define XR_CPP_NULLPTR_SUPPORTED 0 +#endif // !defined(XR_CPP_NULLPTR_SUPPORTED) + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/shadps4-arm64-main/externals/openxr-sdk/include/openxr/openxr_reflection.h b/shadps4-arm64-main/externals/openxr-sdk/include/openxr/openxr_reflection.h new file mode 100644 index 0000000..56118a0 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/include/openxr/openxr_reflection.h @@ -0,0 +1,13038 @@ +#ifndef OPENXR_REFLECTION_H_ +#define OPENXR_REFLECTION_H_ 1 + +/* +** Copyright (c) 2017-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 OR MIT +*/ + +/* +** This header is generated from the Khronos OpenXR XML API Registry. +** +*/ + +#include "openxr.h" + +/* +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_EXTENSION_DEPENDENCY_NOT_ENABLED, -1000710001) \ + _(XR_ERROR_PERMISSION_INSUFFICIENT, -1000710000) \ + _(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_SPACE_COMPONENT_NOT_SUPPORTED_FB, -1000113000) \ + _(XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB, -1000113001) \ + _(XR_ERROR_SPACE_COMPONENT_STATUS_PENDING_FB, -1000113002) \ + _(XR_ERROR_SPACE_COMPONENT_STATUS_ALREADY_SET_FB, -1000113003) \ + _(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_MARKER_DETECTOR_PERMISSION_DENIED_ML, -1000138000) \ + _(XR_ERROR_MARKER_DETECTOR_LOCATE_FAILED_ML, -1000138001) \ + _(XR_ERROR_MARKER_DETECTOR_INVALID_DATA_QUERY_ML, -1000138002) \ + _(XR_ERROR_MARKER_DETECTOR_INVALID_CREATE_INFO_ML, -1000138003) \ + _(XR_ERROR_MARKER_INVALID_ML, -1000138004) \ + _(XR_ERROR_LOCALIZATION_MAP_INCOMPATIBLE_ML, -1000139000) \ + _(XR_ERROR_LOCALIZATION_MAP_UNAVAILABLE_ML, -1000139001) \ + _(XR_ERROR_LOCALIZATION_MAP_FAIL_ML, -1000139002) \ + _(XR_ERROR_LOCALIZATION_MAP_IMPORT_EXPORT_PERMISSION_DENIED_ML, -1000139003) \ + _(XR_ERROR_LOCALIZATION_MAP_PERMISSION_DENIED_ML, -1000139004) \ + _(XR_ERROR_LOCALIZATION_MAP_ALREADY_EXISTS_ML, -1000139005) \ + _(XR_ERROR_LOCALIZATION_MAP_CANNOT_EXPORT_CLOUD_MAP_ML, -1000139006) \ + _(XR_ERROR_SPATIAL_ANCHORS_PERMISSION_DENIED_ML, -1000140000) \ + _(XR_ERROR_SPATIAL_ANCHORS_NOT_LOCALIZED_ML, -1000140001) \ + _(XR_ERROR_SPATIAL_ANCHORS_OUT_OF_MAP_BOUNDS_ML, -1000140002) \ + _(XR_ERROR_SPATIAL_ANCHORS_SPACE_NOT_LOCATABLE_ML, -1000140003) \ + _(XR_ERROR_SPATIAL_ANCHORS_ANCHOR_NOT_FOUND_ML, -1000141000) \ + _(XR_ERROR_SPATIAL_ANCHOR_NAME_NOT_FOUND_MSFT, -1000142001) \ + _(XR_ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT, -1000142002) \ + _(XR_SCENE_MARKER_DATA_NOT_STRING_MSFT, 1000147000) \ + _(XR_ERROR_SPACE_MAPPING_INSUFFICIENT_FB, -1000169000) \ + _(XR_ERROR_SPACE_LOCALIZATION_FAILED_FB, -1000169001) \ + _(XR_ERROR_SPACE_NETWORK_TIMEOUT_FB, -1000169002) \ + _(XR_ERROR_SPACE_NETWORK_REQUEST_FAILED_FB, -1000169003) \ + _(XR_ERROR_SPACE_CLOUD_STORAGE_DISABLED_FB, -1000169004) \ + _(XR_ERROR_SPACE_INSUFFICIENT_RESOURCES_META, -1000259000) \ + _(XR_ERROR_SPACE_STORAGE_AT_CAPACITY_META, -1000259001) \ + _(XR_ERROR_SPACE_INSUFFICIENT_VIEW_META, -1000259002) \ + _(XR_ERROR_SPACE_PERMISSION_INSUFFICIENT_META, -1000259003) \ + _(XR_ERROR_SPACE_RATE_LIMITED_META, -1000259004) \ + _(XR_ERROR_SPACE_TOO_DARK_META, -1000259005) \ + _(XR_ERROR_SPACE_TOO_BRIGHT_META, -1000259006) \ + _(XR_ERROR_PASSTHROUGH_COLOR_LUT_BUFFER_SIZE_MISMATCH_META, -1000266000) \ + _(XR_ENVIRONMENT_DEPTH_NOT_AVAILABLE_META, 1000291000) \ + _(XR_ERROR_RENDER_MODEL_ID_INVALID_EXT, -1000300000) \ + _(XR_ERROR_RENDER_MODEL_ASSET_UNAVAILABLE_EXT, -1000300001) \ + _(XR_ERROR_RENDER_MODEL_GLTF_EXTENSION_REQUIRED_EXT, -1000300002) \ + _(XR_ERROR_NOT_INTERACTION_RENDER_MODEL_EXT, -1000301000) \ + _(XR_ERROR_HINT_ALREADY_SET_QCOM, -1000306000) \ + _(XR_ERROR_NOT_AN_ANCHOR_HTC, -1000319000) \ + _(XR_ERROR_SPATIAL_ENTITY_ID_INVALID_BD, -1000389000) \ + _(XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD, -1000389001) \ + _(XR_ERROR_ANCHOR_NOT_SUPPORTED_FOR_ENTITY_BD, -1000389002) \ + _(XR_ERROR_SPATIAL_ANCHOR_NOT_FOUND_BD, -1000390000) \ + _(XR_ERROR_SPATIAL_ANCHOR_SHARING_NETWORK_TIMEOUT_BD, -1000391000) \ + _(XR_ERROR_SPATIAL_ANCHOR_SHARING_AUTHENTICATION_FAILURE_BD, -1000391001) \ + _(XR_ERROR_SPATIAL_ANCHOR_SHARING_NETWORK_FAILURE_BD, -1000391002) \ + _(XR_ERROR_SPATIAL_ANCHOR_SHARING_LOCALIZATION_FAIL_BD, -1000391003) \ + _(XR_ERROR_SPATIAL_ANCHOR_SHARING_MAP_INSUFFICIENT_BD, -1000391004) \ + _(XR_ERROR_SCENE_CAPTURE_FAILURE_BD, -1000392000) \ + _(XR_ERROR_SPACE_NOT_LOCATABLE_EXT, -1000429000) \ + _(XR_ERROR_PLANE_DETECTION_PERMISSION_DENIED_EXT, -1000429001) \ + _(XR_ERROR_MISMATCHING_TRACKABLE_TYPE_ANDROID, -1000455000) \ + _(XR_ERROR_TRACKABLE_TYPE_NOT_SUPPORTED_ANDROID, -1000455001) \ + _(XR_ERROR_ANCHOR_ID_NOT_FOUND_ANDROID, -1000457000) \ + _(XR_ERROR_ANCHOR_ALREADY_PERSISTED_ANDROID, -1000457001) \ + _(XR_ERROR_ANCHOR_NOT_TRACKING_ANDROID, -1000457002) \ + _(XR_ERROR_PERSISTED_DATA_NOT_READY_ANDROID, -1000457003) \ + _(XR_ERROR_SERVICE_NOT_READY_ANDROID, -1000458000) \ + _(XR_ERROR_MESH_DATA_LIMIT_EXCEEDED_ANDROID, -1000462000) \ + _(XR_ERROR_FUTURE_PENDING_EXT, -1000469001) \ + _(XR_ERROR_FUTURE_INVALID_EXT, -1000469002) \ + _(XR_ERROR_SYSTEM_NOTIFICATION_PERMISSION_DENIED_ML, -1000473000) \ + _(XR_ERROR_SYSTEM_NOTIFICATION_INCOMPATIBLE_SKU_ML, -1000473001) \ + _(XR_ERROR_WORLD_MESH_DETECTOR_PERMISSION_DENIED_ML, -1000474000) \ + _(XR_ERROR_WORLD_MESH_DETECTOR_SPACE_NOT_LOCATABLE_ML, -1000474001) \ + _(XR_ERROR_FACIAL_EXPRESSION_PERMISSION_DENIED_ML, 1000482000) \ + _(XR_BOUNDARY_VISIBILITY_SUPPRESSION_NOT_ALLOWED_META, 1000528000) \ + _(XR_ERROR_COLOCATION_DISCOVERY_NETWORK_FAILED_META, -1000571001) \ + _(XR_ERROR_COLOCATION_DISCOVERY_NO_DISCOVERY_METHOD_META, -1000571002) \ + _(XR_COLOCATION_DISCOVERY_ALREADY_ADVERTISING_META, 1000571003) \ + _(XR_COLOCATION_DISCOVERY_ALREADY_DISCOVERING_META, 1000571004) \ + _(XR_ERROR_SPACE_GROUP_NOT_FOUND_META, -1000572002) \ + _(XR_ERROR_ANCHOR_NOT_OWNED_BY_CALLER_ANDROID, -1000701000) \ + _(XR_ERROR_IMAGE_FORMAT_UNSUPPORTED_ANDROID, -1000709000) \ + _(XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT, -1000740001) \ + _(XR_ERROR_SPATIAL_ENTITY_ID_INVALID_EXT, -1000740002) \ + _(XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT, -1000740003) \ + _(XR_ERROR_SPATIAL_COMPONENT_UNSUPPORTED_FOR_CAPABILITY_EXT, -1000740004) \ + _(XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT, -1000740005) \ + _(XR_ERROR_SPATIAL_COMPONENT_NOT_ENABLED_EXT, -1000740006) \ + _(XR_ERROR_CAMERA_UNAVAILABLE_BD, -1000755000) \ + _(XR_ERROR_CAMERA_OCCUPIED_BD, -1000755001) \ + _(XR_ERROR_CAMERA_CAPTURE_SESSION_CAPTURING_BD, -1000755002) \ + _(XR_ERROR_CAMERA_CAPTURE_SESSION_NOT_CAPTURING_BD, -1000755003) \ + _(XR_ERROR_CAMERA_ID_INVALID_BD, -1000755004) \ + _(XR_ERROR_CAMERA_IMAGE_ID_INVALID_BD, -1000755005) \ + _(XR_ERROR_CAMERA_PROPERTY_TYPE_INVALID_BD, -1000755006) \ + _(XR_ERROR_CAMERA_CAPABILITY_TYPE_INVALID_BD, -1000755007) \ + _(XR_ERROR_IMAGE_BUFFER_EXHAUSTED_BD, -1000755008) \ + _(XR_ERROR_SPATIAL_PERSISTENCE_SCOPE_UNSUPPORTED_EXT, -1000763001) \ + _(XR_ERROR_SPATIAL_PERSISTENCE_SCOPE_INCOMPATIBLE_EXT, -1000781001) \ + _(XR_ERROR_SPATIAL_IMAGE_FORMAT_UNSUPPORTED_EXT, -1000782001) \ + _(XR_ERROR_SPATIAL_IMAGE_INVALID_EXT, -1000782002) \ + _(XR_ERROR_SPATIAL_IMAGE_SIZE_MISSING_EXT, -1000782003) \ + _(XR_ERROR_KEYLESS_AUTH_NOT_SETUP_ANDROID, -1000787000) \ + _(XR_ERROR_KEYLESS_AUTH_FAILED_ANDROID, -1000787001) \ + _(XR_ERROR_GEOSPATIAL_TRACKER_NOT_RUNNING_ANDROID, -1000789000) \ + _(XR_ERROR_GEOSPATIAL_COORDINATES_INVALID_ANDROID, -1000789001) \ + _(XR_ERROR_GEOSPATIAL_CLOUD_AUTH_FAILED_ANDROID, -1000789002) \ + _(XR_ERROR_SPATIAL_ANCHOR_ATTACHABLE_COMPONENT_NOT_FOUND_ANDROID, -1000790001) \ + _(XR_ERROR_SPATIAL_ANCHOR_ENTITY_ID_INVALID_ANDROID, -1000795001) \ + _(XR_ERROR_SURFACE_ANCHOR_LOCATION_UNSUPPORTED_ANDROID, -1000797000) \ + _(XR_ERROR_SPATIAL_CONTAINER_CLOSED_EXT, -1000810000) \ + _(XR_ERROR_SPATIAL_CONTAINERS_ENABLED_EXT, -1000810001) \ + _(XR_ERROR_SPATIAL_CONTAINERS_NOT_ENABLED_EXT, -1000810002) \ + _(XR_ERROR_COMPATIBLE_SPATIAL_CONTAINER_MISSING_EXT, -1000810003) \ + _(XR_ERROR_SPATIAL_CONTAINER_IS_RENDERING_EXT, -1000813001) \ + _(XR_ERROR_SPATIAL_CONTAINER_NOT_RENDERING_EXT, -1000813002) \ + _(XR_ERROR_SPATIAL_CONTAINER_MISSING_EXT, -1000813003) \ + _(XR_ERROR_SPATIAL_CONTAINER_DUPLICATE_EXT, -1000813004) \ + _(XR_ERROR_SPATIAL_CONTAINER_GRAPHICS_PRESENTATION_MISSING_EXT, -1000813005) \ + _(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_SPACES_LOCATE_INFO, 1000471000) \ + _(XR_TYPE_SPACE_LOCATIONS, 1000471001) \ + _(XR_TYPE_SPACE_VELOCITIES, 1000471002) \ + _(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_GRAPHICS_BINDING_METAL_KHR, 1000029000) \ + _(XR_TYPE_SWAPCHAIN_IMAGE_METAL_KHR, 1000029001) \ + _(XR_TYPE_GRAPHICS_REQUIREMENTS_METAL_KHR, 1000029002) \ + _(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_SPATIAL_GRAPH_STATIC_NODE_BINDING_CREATE_INFO_MSFT, 1000049001) \ + _(XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_GET_INFO_MSFT, 1000049002) \ + _(XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_MSFT, 1000049003) \ + _(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_BODY_TRACKER_CREATE_INFO_FB, 1000076001) \ + _(XR_TYPE_BODY_JOINTS_LOCATE_INFO_FB, 1000076002) \ + _(XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_FB, 1000076004) \ + _(XR_TYPE_BODY_JOINT_LOCATIONS_FB, 1000076005) \ + _(XR_TYPE_BODY_SKELETON_FB, 1000076006) \ + _(XR_TYPE_INTERACTION_PROFILE_DPAD_BINDING_EXT, 1000078000) \ + _(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_SYSTEM_SPATIAL_ENTITY_PROPERTIES_FB, 1000113004) \ + _(XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_FB, 1000113003) \ + _(XR_TYPE_SPACE_COMPONENT_STATUS_SET_INFO_FB, 1000113007) \ + _(XR_TYPE_SPACE_COMPONENT_STATUS_FB, 1000113001) \ + _(XR_TYPE_EVENT_DATA_SPATIAL_ANCHOR_CREATE_COMPLETE_FB, 1000113005) \ + _(XR_TYPE_EVENT_DATA_SPACE_SET_STATUS_COMPLETE_FB, 1000113006) \ + _(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_SYSTEM_PASSTHROUGH_PROPERTIES2_FB, 1000118006) \ + _(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_PASSTHROUGH_BRIGHTNESS_CONTRAST_SATURATION_FB, 1000118023) \ + _(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_RENDER_MODEL_CAPABILITIES_REQUEST_FB, 1000119005) \ + _(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_FRAME_END_INFO_ML, 1000135000) \ + _(XR_TYPE_GLOBAL_DIMMER_FRAME_END_INFO_ML, 1000136000) \ + _(XR_TYPE_COORDINATE_SPACE_CREATE_INFO_ML, 1000137000) \ + _(XR_TYPE_SYSTEM_MARKER_UNDERSTANDING_PROPERTIES_ML, 1000138000) \ + _(XR_TYPE_MARKER_DETECTOR_CREATE_INFO_ML, 1000138001) \ + _(XR_TYPE_MARKER_DETECTOR_ARUCO_INFO_ML, 1000138002) \ + _(XR_TYPE_MARKER_DETECTOR_SIZE_INFO_ML, 1000138003) \ + _(XR_TYPE_MARKER_DETECTOR_APRIL_TAG_INFO_ML, 1000138004) \ + _(XR_TYPE_MARKER_DETECTOR_CUSTOM_PROFILE_INFO_ML, 1000138005) \ + _(XR_TYPE_MARKER_DETECTOR_SNAPSHOT_INFO_ML, 1000138006) \ + _(XR_TYPE_MARKER_DETECTOR_STATE_ML, 1000138007) \ + _(XR_TYPE_MARKER_SPACE_CREATE_INFO_ML, 1000138008) \ + _(XR_TYPE_LOCALIZATION_MAP_ML, 1000139000) \ + _(XR_TYPE_EVENT_DATA_LOCALIZATION_CHANGED_ML, 1000139001) \ + _(XR_TYPE_MAP_LOCALIZATION_REQUEST_INFO_ML, 1000139002) \ + _(XR_TYPE_LOCALIZATION_MAP_IMPORT_INFO_ML, 1000139003) \ + _(XR_TYPE_LOCALIZATION_ENABLE_EVENTS_INFO_ML, 1000139004) \ + _(XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_POSE_ML, 1000140000) \ + _(XR_TYPE_CREATE_SPATIAL_ANCHORS_COMPLETION_ML, 1000140001) \ + _(XR_TYPE_SPATIAL_ANCHOR_STATE_ML, 1000140002) \ + _(XR_TYPE_SPATIAL_ANCHORS_CREATE_STORAGE_INFO_ML, 1000141000) \ + _(XR_TYPE_SPATIAL_ANCHORS_QUERY_INFO_RADIUS_ML, 1000141001) \ + _(XR_TYPE_SPATIAL_ANCHORS_QUERY_COMPLETION_ML, 1000141002) \ + _(XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_UUIDS_ML, 1000141003) \ + _(XR_TYPE_SPATIAL_ANCHORS_PUBLISH_INFO_ML, 1000141004) \ + _(XR_TYPE_SPATIAL_ANCHORS_PUBLISH_COMPLETION_ML, 1000141005) \ + _(XR_TYPE_SPATIAL_ANCHORS_DELETE_INFO_ML, 1000141006) \ + _(XR_TYPE_SPATIAL_ANCHORS_DELETE_COMPLETION_ML, 1000141007) \ + _(XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_INFO_ML, 1000141008) \ + _(XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_COMPLETION_ML, 1000141009) \ + _(XR_TYPE_SPATIAL_ANCHORS_PUBLISH_COMPLETION_DETAILS_ML, 1000141010) \ + _(XR_TYPE_SPATIAL_ANCHORS_DELETE_COMPLETION_DETAILS_ML, 1000141011) \ + _(XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_COMPLETION_DETAILS_ML, 1000141012) \ + _(XR_TYPE_EVENT_DATA_HEADSET_FIT_CHANGED_ML, 1000472000) \ + _(XR_TYPE_EVENT_DATA_EYE_CALIBRATION_CHANGED_ML, 1000472001) \ + _(XR_TYPE_USER_CALIBRATION_ENABLE_EVENTS_INFO_ML, 1000472002) \ + _(XR_TYPE_SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT, 1000142000) \ + _(XR_TYPE_SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_INFO_MSFT, 1000142001) \ + _(XR_TYPE_SCENE_MARKERS_MSFT, 1000147000) \ + _(XR_TYPE_SCENE_MARKER_TYPE_FILTER_MSFT, 1000147001) \ + _(XR_TYPE_SCENE_MARKER_QR_CODES_MSFT, 1000147002) \ + _(XR_TYPE_SPACE_QUERY_INFO_FB, 1000156001) \ + _(XR_TYPE_SPACE_QUERY_RESULTS_FB, 1000156002) \ + _(XR_TYPE_SPACE_STORAGE_LOCATION_FILTER_INFO_FB, 1000156003) \ + _(XR_TYPE_SPACE_UUID_FILTER_INFO_FB, 1000156054) \ + _(XR_TYPE_SPACE_COMPONENT_FILTER_INFO_FB, 1000156052) \ + _(XR_TYPE_EVENT_DATA_SPACE_QUERY_RESULTS_AVAILABLE_FB, 1000156103) \ + _(XR_TYPE_EVENT_DATA_SPACE_QUERY_COMPLETE_FB, 1000156104) \ + _(XR_TYPE_SPACE_SAVE_INFO_FB, 1000158000) \ + _(XR_TYPE_SPACE_ERASE_INFO_FB, 1000158001) \ + _(XR_TYPE_EVENT_DATA_SPACE_SAVE_COMPLETE_FB, 1000158106) \ + _(XR_TYPE_EVENT_DATA_SPACE_ERASE_COMPLETE_FB, 1000158107) \ + _(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_SPACE_SHARE_INFO_FB, 1000169001) \ + _(XR_TYPE_EVENT_DATA_SPACE_SHARE_COMPLETE_FB, 1000169002) \ + _(XR_TYPE_COMPOSITION_LAYER_SPACE_WARP_INFO_FB, 1000171000) \ + _(XR_TYPE_SYSTEM_SPACE_WARP_PROPERTIES_FB, 1000171001) \ + _(XR_TYPE_HAPTIC_AMPLITUDE_ENVELOPE_VIBRATION_FB, 1000173001) \ + _(XR_TYPE_SEMANTIC_LABELS_FB, 1000175000) \ + _(XR_TYPE_ROOM_LAYOUT_FB, 1000175001) \ + _(XR_TYPE_BOUNDARY_2D_FB, 1000175002) \ + _(XR_TYPE_SEMANTIC_LABELS_SUPPORT_INFO_FB, 1000175010) \ + _(XR_TYPE_DIGITAL_LENS_CONTROL_ALMALENCE, 1000196000) \ + _(XR_TYPE_EVENT_DATA_SCENE_CAPTURE_COMPLETE_FB, 1000198001) \ + _(XR_TYPE_SCENE_CAPTURE_REQUEST_INFO_FB, 1000198050) \ + _(XR_TYPE_SPACE_CONTAINER_FB, 1000199000) \ + _(XR_TYPE_FOVEATION_EYE_TRACKED_PROFILE_CREATE_INFO_META, 1000200000) \ + _(XR_TYPE_FOVEATION_EYE_TRACKED_STATE_META, 1000200001) \ + _(XR_TYPE_SYSTEM_FOVEATION_EYE_TRACKED_PROPERTIES_META, 1000200002) \ + _(XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES_FB, 1000201004) \ + _(XR_TYPE_FACE_TRACKER_CREATE_INFO_FB, 1000201005) \ + _(XR_TYPE_FACE_EXPRESSION_INFO_FB, 1000201002) \ + _(XR_TYPE_FACE_EXPRESSION_WEIGHTS_FB, 1000201006) \ + _(XR_TYPE_EYE_TRACKER_CREATE_INFO_FB, 1000202001) \ + _(XR_TYPE_EYE_GAZES_INFO_FB, 1000202002) \ + _(XR_TYPE_EYE_GAZES_FB, 1000202003) \ + _(XR_TYPE_SYSTEM_EYE_TRACKING_PROPERTIES_FB, 1000202004) \ + _(XR_TYPE_PASSTHROUGH_KEYBOARD_HANDS_INTENSITY_FB, 1000203002) \ + _(XR_TYPE_COMPOSITION_LAYER_SETTINGS_FB, 1000204000) \ + _(XR_TYPE_HAPTIC_PCM_VIBRATION_FB, 1000209001) \ + _(XR_TYPE_DEVICE_PCM_SAMPLE_RATE_STATE_FB, 1000209002) \ + _(XR_TYPE_FRAME_SYNTHESIS_INFO_EXT, 1000211000) \ + _(XR_TYPE_FRAME_SYNTHESIS_CONFIG_VIEW_EXT, 1000211001) \ + _(XR_TYPE_COMPOSITION_LAYER_DEPTH_TEST_FB, 1000212000) \ + _(XR_TYPE_LOCAL_DIMMING_FRAME_END_INFO_META, 1000216000) \ + _(XR_TYPE_PASSTHROUGH_PREFERENCES_META, 1000217000) \ + _(XR_TYPE_SYSTEM_VIRTUAL_KEYBOARD_PROPERTIES_META, 1000219001) \ + _(XR_TYPE_VIRTUAL_KEYBOARD_CREATE_INFO_META, 1000219002) \ + _(XR_TYPE_VIRTUAL_KEYBOARD_SPACE_CREATE_INFO_META, 1000219003) \ + _(XR_TYPE_VIRTUAL_KEYBOARD_LOCATION_INFO_META, 1000219004) \ + _(XR_TYPE_VIRTUAL_KEYBOARD_MODEL_VISIBILITY_SET_INFO_META, 1000219005) \ + _(XR_TYPE_VIRTUAL_KEYBOARD_ANIMATION_STATE_META, 1000219006) \ + _(XR_TYPE_VIRTUAL_KEYBOARD_MODEL_ANIMATION_STATES_META, 1000219007) \ + _(XR_TYPE_VIRTUAL_KEYBOARD_TEXTURE_DATA_META, 1000219009) \ + _(XR_TYPE_VIRTUAL_KEYBOARD_INPUT_INFO_META, 1000219010) \ + _(XR_TYPE_VIRTUAL_KEYBOARD_TEXT_CONTEXT_CHANGE_INFO_META, 1000219011) \ + _(XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_COMMIT_TEXT_META, 1000219014) \ + _(XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_BACKSPACE_META, 1000219015) \ + _(XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_ENTER_META, 1000219016) \ + _(XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_SHOWN_META, 1000219017) \ + _(XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_HIDDEN_META, 1000219018) \ + _(XR_TYPE_EXTERNAL_CAMERA_OCULUS, 1000226000) \ + _(XR_TYPE_VULKAN_SWAPCHAIN_CREATE_INFO_META, 1000227000) \ + _(XR_TYPE_PERFORMANCE_METRICS_STATE_META, 1000232001) \ + _(XR_TYPE_PERFORMANCE_METRICS_COUNTER_META, 1000232002) \ + _(XR_TYPE_SPACE_LIST_SAVE_INFO_FB, 1000238000) \ + _(XR_TYPE_EVENT_DATA_SPACE_LIST_SAVE_COMPLETE_FB, 1000238001) \ + _(XR_TYPE_SPACE_USER_CREATE_INFO_FB, 1000241001) \ + _(XR_TYPE_SYSTEM_HEADSET_ID_PROPERTIES_META, 1000245000) \ + _(XR_TYPE_SYSTEM_SPACE_DISCOVERY_PROPERTIES_META, 1000247000) \ + _(XR_TYPE_SPACE_DISCOVERY_INFO_META, 1000247001) \ + _(XR_TYPE_SPACE_FILTER_UUID_META, 1000247003) \ + _(XR_TYPE_SPACE_FILTER_COMPONENT_META, 1000247004) \ + _(XR_TYPE_SPACE_DISCOVERY_RESULT_META, 1000247005) \ + _(XR_TYPE_SPACE_DISCOVERY_RESULTS_META, 1000247006) \ + _(XR_TYPE_EVENT_DATA_SPACE_DISCOVERY_RESULTS_AVAILABLE_META, 1000247007) \ + _(XR_TYPE_EVENT_DATA_SPACE_DISCOVERY_COMPLETE_META, 1000247008) \ + _(XR_TYPE_RECOMMENDED_LAYER_RESOLUTION_META, 1000254000) \ + _(XR_TYPE_RECOMMENDED_LAYER_RESOLUTION_GET_INFO_META, 1000254001) \ + _(XR_TYPE_SYSTEM_SPACE_PERSISTENCE_PROPERTIES_META, 1000259000) \ + _(XR_TYPE_SPACES_SAVE_INFO_META, 1000259001) \ + _(XR_TYPE_EVENT_DATA_SPACES_SAVE_RESULT_META, 1000259002) \ + _(XR_TYPE_SPACES_ERASE_INFO_META, 1000259003) \ + _(XR_TYPE_EVENT_DATA_SPACES_ERASE_RESULT_META, 1000259004) \ + _(XR_TYPE_SYSTEM_PASSTHROUGH_COLOR_LUT_PROPERTIES_META, 1000266000) \ + _(XR_TYPE_PASSTHROUGH_COLOR_LUT_CREATE_INFO_META, 1000266001) \ + _(XR_TYPE_PASSTHROUGH_COLOR_LUT_UPDATE_INFO_META, 1000266002) \ + _(XR_TYPE_PASSTHROUGH_COLOR_MAP_LUT_META, 1000266100) \ + _(XR_TYPE_PASSTHROUGH_COLOR_MAP_INTERPOLATED_LUT_META, 1000266101) \ + _(XR_TYPE_SPACE_TRIANGLE_MESH_GET_INFO_META, 1000269001) \ + _(XR_TYPE_SPACE_TRIANGLE_MESH_META, 1000269002) \ + _(XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_FULL_BODY_META, 1000274000) \ + _(XR_TYPE_EVENT_DATA_PASSTHROUGH_LAYER_RESUMED_META, 1000282000) \ + _(XR_TYPE_BODY_TRACKING_CALIBRATION_INFO_META, 1000283002) \ + _(XR_TYPE_BODY_TRACKING_CALIBRATION_STATUS_META, 1000283003) \ + _(XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_CALIBRATION_META, 1000283004) \ + _(XR_TYPE_BODY_TRACKING_FIDELITY_STATUS_META, 1000284000) \ + _(XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_FIDELITY_META, 1000284001) \ + _(XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES2_FB, 1000287013) \ + _(XR_TYPE_FACE_TRACKER_CREATE_INFO2_FB, 1000287014) \ + _(XR_TYPE_FACE_EXPRESSION_INFO2_FB, 1000287015) \ + _(XR_TYPE_FACE_EXPRESSION_WEIGHTS2_FB, 1000287016) \ + _(XR_TYPE_SYSTEM_SPATIAL_ENTITY_SHARING_PROPERTIES_META, 1000290000) \ + _(XR_TYPE_SHARE_SPACES_INFO_META, 1000290001) \ + _(XR_TYPE_EVENT_DATA_SHARE_SPACES_COMPLETE_META, 1000290002) \ + _(XR_TYPE_ENVIRONMENT_DEPTH_PROVIDER_CREATE_INFO_META, 1000291000) \ + _(XR_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_CREATE_INFO_META, 1000291001) \ + _(XR_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_STATE_META, 1000291002) \ + _(XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_ACQUIRE_INFO_META, 1000291003) \ + _(XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_VIEW_META, 1000291004) \ + _(XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_META, 1000291005) \ + _(XR_TYPE_ENVIRONMENT_DEPTH_HAND_REMOVAL_SET_INFO_META, 1000291006) \ + _(XR_TYPE_SYSTEM_ENVIRONMENT_DEPTH_PROPERTIES_META, 1000291007) \ + _(XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_TIMESTAMP_META, 1000291008) \ + _(XR_TYPE_RENDER_MODEL_CREATE_INFO_EXT, 1000300000) \ + _(XR_TYPE_RENDER_MODEL_PROPERTIES_GET_INFO_EXT, 1000300001) \ + _(XR_TYPE_RENDER_MODEL_PROPERTIES_EXT, 1000300002) \ + _(XR_TYPE_RENDER_MODEL_SPACE_CREATE_INFO_EXT, 1000300003) \ + _(XR_TYPE_RENDER_MODEL_STATE_GET_INFO_EXT, 1000300004) \ + _(XR_TYPE_RENDER_MODEL_STATE_EXT, 1000300005) \ + _(XR_TYPE_RENDER_MODEL_ASSET_CREATE_INFO_EXT, 1000300006) \ + _(XR_TYPE_RENDER_MODEL_ASSET_DATA_GET_INFO_EXT, 1000300007) \ + _(XR_TYPE_RENDER_MODEL_ASSET_DATA_EXT, 1000300008) \ + _(XR_TYPE_RENDER_MODEL_ASSET_PROPERTIES_GET_INFO_EXT, 1000300009) \ + _(XR_TYPE_RENDER_MODEL_ASSET_PROPERTIES_EXT, 1000300010) \ + _(XR_TYPE_INTERACTION_RENDER_MODEL_IDS_ENUMERATE_INFO_EXT, 1000301000) \ + _(XR_TYPE_INTERACTION_RENDER_MODEL_SUBACTION_PATH_INFO_EXT, 1000301001) \ + _(XR_TYPE_EVENT_DATA_INTERACTION_RENDER_MODELS_CHANGED_EXT, 1000301002) \ + _(XR_TYPE_INTERACTION_RENDER_MODEL_TOP_LEVEL_USER_PATH_GET_INFO_EXT, 1000301003) \ + _(XR_TYPE_PASSTHROUGH_CREATE_INFO_HTC, 1000317001) \ + _(XR_TYPE_PASSTHROUGH_COLOR_HTC, 1000317002) \ + _(XR_TYPE_PASSTHROUGH_MESH_TRANSFORM_INFO_HTC, 1000317003) \ + _(XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_HTC, 1000317004) \ + _(XR_TYPE_FOVEATION_APPLY_INFO_HTC, 1000318000) \ + _(XR_TYPE_FOVEATION_DYNAMIC_MODE_INFO_HTC, 1000318001) \ + _(XR_TYPE_FOVEATION_CUSTOM_MODE_INFO_HTC, 1000318002) \ + _(XR_TYPE_SYSTEM_ANCHOR_PROPERTIES_HTC, 1000319000) \ + _(XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_HTC, 1000319001) \ + _(XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_HTC, 1000320000) \ + _(XR_TYPE_BODY_TRACKER_CREATE_INFO_HTC, 1000320001) \ + _(XR_TYPE_BODY_JOINTS_LOCATE_INFO_HTC, 1000320002) \ + _(XR_TYPE_BODY_JOINT_LOCATIONS_HTC, 1000320003) \ + _(XR_TYPE_BODY_SKELETON_HTC, 1000320004) \ + _(XR_TYPE_ACTIVE_ACTION_SET_PRIORITIES_EXT, 1000373000) \ + _(XR_TYPE_SYSTEM_FORCE_FEEDBACK_CURL_PROPERTIES_MNDX, 1000375000) \ + _(XR_TYPE_FORCE_FEEDBACK_CURL_APPLY_LOCATIONS_MNDX, 1000375001) \ + _(XR_TYPE_BODY_TRACKER_CREATE_INFO_BD, 1000385001) \ + _(XR_TYPE_BODY_JOINTS_LOCATE_INFO_BD, 1000385002) \ + _(XR_TYPE_BODY_JOINT_LOCATIONS_BD, 1000385003) \ + _(XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_BD, 1000385004) \ + _(XR_TYPE_SYSTEM_FACIAL_SIMULATION_PROPERTIES_BD, 1000386001) \ + _(XR_TYPE_FACE_TRACKER_CREATE_INFO_BD, 1000386002) \ + _(XR_TYPE_FACIAL_SIMULATION_DATA_GET_INFO_BD, 1000386003) \ + _(XR_TYPE_FACIAL_SIMULATION_DATA_BD, 1000386004) \ + _(XR_TYPE_LIP_EXPRESSION_DATA_BD, 1000386005) \ + _(XR_TYPE_SYSTEM_SPATIAL_SENSING_PROPERTIES_BD, 1000389000) \ + _(XR_TYPE_SPATIAL_ENTITY_COMPONENT_GET_INFO_BD, 1000389001) \ + _(XR_TYPE_SPATIAL_ENTITY_LOCATION_GET_INFO_BD, 1000389002) \ + _(XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_LOCATION_BD, 1000389003) \ + _(XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_SEMANTIC_BD, 1000389004) \ + _(XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_BOUNDING_BOX_2D_BD, 1000389005) \ + _(XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_POLYGON_BD, 1000389006) \ + _(XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_BOUNDING_BOX_3D_BD, 1000389007) \ + _(XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_TRIANGLE_MESH_BD, 1000389008) \ + _(XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_BD, 1000389009) \ + _(XR_TYPE_SENSE_DATA_PROVIDER_START_INFO_BD, 1000389010) \ + _(XR_TYPE_EVENT_DATA_SENSE_DATA_PROVIDER_STATE_CHANGED_BD, 1000389011) \ + _(XR_TYPE_EVENT_DATA_SENSE_DATA_UPDATED_BD, 1000389012) \ + _(XR_TYPE_SENSE_DATA_QUERY_INFO_BD, 1000389013) \ + _(XR_TYPE_SENSE_DATA_QUERY_COMPLETION_BD, 1000389014) \ + _(XR_TYPE_SENSE_DATA_FILTER_UUID_BD, 1000389015) \ + _(XR_TYPE_SENSE_DATA_FILTER_SEMANTIC_BD, 1000389016) \ + _(XR_TYPE_QUERIED_SENSE_DATA_GET_INFO_BD, 1000389017) \ + _(XR_TYPE_QUERIED_SENSE_DATA_BD, 1000389018) \ + _(XR_TYPE_SPATIAL_ENTITY_STATE_BD, 1000389019) \ + _(XR_TYPE_SPATIAL_ENTITY_ANCHOR_CREATE_INFO_BD, 1000389020) \ + _(XR_TYPE_ANCHOR_SPACE_CREATE_INFO_BD, 1000389021) \ + _(XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_SPHERE_BD, 1000389022) \ + _(XR_TYPE_SYSTEM_SPATIAL_ANCHOR_PROPERTIES_BD, 1000390000) \ + _(XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_BD, 1000390001) \ + _(XR_TYPE_SPATIAL_ANCHOR_CREATE_COMPLETION_BD, 1000390002) \ + _(XR_TYPE_SPATIAL_ANCHOR_PERSIST_INFO_BD, 1000390003) \ + _(XR_TYPE_SPATIAL_ANCHOR_UNPERSIST_INFO_BD, 1000390004) \ + _(XR_TYPE_SYSTEM_SPATIAL_ANCHOR_SHARING_PROPERTIES_BD, 1000391000) \ + _(XR_TYPE_SPATIAL_ANCHOR_SHARE_INFO_BD, 1000391001) \ + _(XR_TYPE_SHARED_SPATIAL_ANCHOR_DOWNLOAD_INFO_BD, 1000391002) \ + _(XR_TYPE_SYSTEM_SPATIAL_SCENE_PROPERTIES_BD, 1000392000) \ + _(XR_TYPE_SCENE_CAPTURE_INFO_BD, 1000392001) \ + _(XR_TYPE_SYSTEM_SPATIAL_MESH_PROPERTIES_BD, 1000393000) \ + _(XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_SPATIAL_MESH_BD, 1000393001) \ + _(XR_TYPE_FUTURE_POLL_RESULT_PROGRESS_BD, 1000394001) \ + _(XR_TYPE_BODY_TRACKING_POSTURE_DATA_BD, 1000395001) \ + _(XR_TYPE_BODY_JOINT_VELOCITIES_BD, 1000395002) \ + _(XR_TYPE_BODY_JOINT_ACCELERATIONS_BD, 1000395003) \ + _(XR_TYPE_BODY_TRACKING_STATE_BD, 1000395004) \ + _(XR_TYPE_SYSTEM_SPATIAL_PLANE_PROPERTIES_BD, 1000396000) \ + _(XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_PLANE_ORIENTATION_BD, 1000396001) \ + _(XR_TYPE_SENSE_DATA_FILTER_PLANE_ORIENTATION_BD, 1000396002) \ + _(XR_TYPE_SYSTEM_LIGHT_ESTIMATION_PROPERTIES_BD, 1000397000) \ + _(XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_LIGHT_ESTIMATION_BD, 1000397001) \ + _(XR_TYPE_ENVIRONMENT_TEXTURE_CREATE_CONFIG_INFO_BD, 1000397002) \ + _(XR_TYPE_LIGHT_ESTIMATION_DATA_ENVIRONMENT_TEXTURE_RAW_BD, 1000397003) \ + _(XR_TYPE_LIGHT_ESTIMATION_DATA_SPHERICAL_HARMONICS_BD, 1000397005) \ + _(XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_LIGHT_ESTIMATION_BD, 1000397006) \ + _(XR_TYPE_SPATIAL_AUDIO_RENDERER_CREATE_INFO_BD, 1000409000) \ + _(XR_TYPE_AUDIO_BUFFER_BD, 1000409001) \ + _(XR_TYPE_SOUND_OBJECT_DIRECTIVITY_CARDIOID_BD, 1000409003) \ + _(XR_TYPE_SOUND_OBJECT_SHAPE_SPHERE_BD, 1000409004) \ + _(XR_TYPE_SOUND_OBJECT_DISTANCE_ATTENUATION_BD, 1000409005) \ + _(XR_TYPE_SOUND_OBJECT_DISTANCE_ATTENUATION_CURVE_BD, 1000409006) \ + _(XR_TYPE_SOUND_OBJECT_CONFIG_BD, 1000409007) \ + _(XR_TYPE_SOUND_FIELD_CONFIG_BD, 1000409008) \ + _(XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_SURROUND_BD, 1000409009) \ + _(XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_AMBIX_BD, 1000409010) \ + _(XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_FUMA_BD, 1000409011) \ + _(XR_TYPE_SOUND_TRIANGLE_MESH_BD, 1000409012) \ + _(XR_TYPE_SOUND_OBSTACLE_CONFIG_BD, 1000409013) \ + _(XR_TYPE_SOUND_OBSTACLE_MATERIAL_CONFIG_BD, 1000409014) \ + _(XR_TYPE_HAND_TRACKING_DATA_SOURCE_INFO_EXT, 1000428000) \ + _(XR_TYPE_HAND_TRACKING_DATA_SOURCE_STATE_EXT, 1000428001) \ + _(XR_TYPE_PLANE_DETECTOR_CREATE_INFO_EXT, 1000429001) \ + _(XR_TYPE_PLANE_DETECTOR_BEGIN_INFO_EXT, 1000429002) \ + _(XR_TYPE_PLANE_DETECTOR_GET_INFO_EXT, 1000429003) \ + _(XR_TYPE_PLANE_DETECTOR_LOCATIONS_EXT, 1000429004) \ + _(XR_TYPE_PLANE_DETECTOR_LOCATION_EXT, 1000429005) \ + _(XR_TYPE_PLANE_DETECTOR_POLYGON_BUFFER_EXT, 1000429006) \ + _(XR_TYPE_SYSTEM_PLANE_DETECTION_PROPERTIES_EXT, 1000429007) \ + _(XR_TYPE_TRACKABLE_GET_INFO_ANDROID, 1000455000) \ + _(XR_TYPE_ANCHOR_SPACE_CREATE_INFO_ANDROID, 1000455001) \ + _(XR_TYPE_TRACKABLE_PLANE_ANDROID, 1000455003) \ + _(XR_TYPE_TRACKABLE_TRACKER_CREATE_INFO_ANDROID, 1000455004) \ + _(XR_TYPE_SYSTEM_TRACKABLES_PROPERTIES_ANDROID, 1000455005) \ + _(XR_TYPE_EYES_ANDROID, 1000456000) \ + _(XR_TYPE_EYE_TRACKER_CREATE_INFO_ANDROID, 1000456001) \ + _(XR_TYPE_EYES_GET_INFO_ANDROID, 1000456002) \ + _(XR_TYPE_SYSTEM_EYE_TRACKING_PROPERTIES_ANDROID, 1000456004) \ + _(XR_TYPE_PERSISTED_ANCHOR_SPACE_CREATE_INFO_ANDROID, 1000457001) \ + _(XR_TYPE_PERSISTED_ANCHOR_SPACE_INFO_ANDROID, 1000457002) \ + _(XR_TYPE_DEVICE_ANCHOR_PERSISTENCE_CREATE_INFO_ANDROID, 1000457003) \ + _(XR_TYPE_SYSTEM_DEVICE_ANCHOR_PERSISTENCE_PROPERTIES_ANDROID, 1000457004) \ + _(XR_TYPE_FACE_TRACKER_CREATE_INFO_ANDROID, 1000458000) \ + _(XR_TYPE_FACE_STATE_GET_INFO_ANDROID, 1000458001) \ + _(XR_TYPE_FACE_STATE_ANDROID, 1000458002) \ + _(XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES_ANDROID, 1000458003) \ + _(XR_TYPE_PASSTHROUGH_CAMERA_STATE_GET_INFO_ANDROID, 1000460000) \ + _(XR_TYPE_SYSTEM_PASSTHROUGH_CAMERA_STATE_PROPERTIES_ANDROID, 1000460001) \ + _(XR_TYPE_EVENT_DATA_RECOMMENDED_RESOLUTION_CHANGED_ANDROID, 1000461000) \ + _(XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_ANDROID, 1000462000) \ + _(XR_TYPE_PASSTHROUGH_LAYER_MESH_ANDROID, 1000462001) \ + _(XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_ANDROID, 1000462002) \ + _(XR_TYPE_SYSTEM_PASSTHROUGH_LAYER_PROPERTIES_ANDROID, 1000462003) \ + _(XR_TYPE_RAYCAST_INFO_ANDROID, 1000463000) \ + _(XR_TYPE_RAYCAST_HIT_RESULTS_ANDROID, 1000463001) \ + _(XR_TYPE_PERFORMANCE_METRICS_STATE_ANDROID, 1000465000) \ + _(XR_TYPE_PERFORMANCE_METRICS_COUNTER_ANDROID, 1000465001) \ + _(XR_TYPE_TRACKABLE_OBJECT_ANDROID, 1000466000) \ + _(XR_TYPE_TRACKABLE_OBJECT_CONFIGURATION_ANDROID, 1000466001) \ + _(XR_TYPE_FUTURE_CANCEL_INFO_EXT, 1000469000) \ + _(XR_TYPE_FUTURE_POLL_INFO_EXT, 1000469001) \ + _(XR_TYPE_FUTURE_COMPLETION_EXT, 1000469002) \ + _(XR_TYPE_FUTURE_POLL_RESULT_EXT, 1000469003) \ + _(XR_TYPE_EVENT_DATA_USER_PRESENCE_CHANGED_EXT, 1000470000) \ + _(XR_TYPE_SYSTEM_USER_PRESENCE_PROPERTIES_EXT, 1000470001) \ + _(XR_TYPE_SYSTEM_NOTIFICATIONS_SET_INFO_ML, 1000473000) \ + _(XR_TYPE_WORLD_MESH_DETECTOR_CREATE_INFO_ML, 1000474001) \ + _(XR_TYPE_WORLD_MESH_STATE_REQUEST_INFO_ML, 1000474002) \ + _(XR_TYPE_WORLD_MESH_BLOCK_STATE_ML, 1000474003) \ + _(XR_TYPE_WORLD_MESH_STATE_REQUEST_COMPLETION_ML, 1000474004) \ + _(XR_TYPE_WORLD_MESH_BUFFER_RECOMMENDED_SIZE_INFO_ML, 1000474005) \ + _(XR_TYPE_WORLD_MESH_BUFFER_SIZE_ML, 1000474006) \ + _(XR_TYPE_WORLD_MESH_BUFFER_ML, 1000474007) \ + _(XR_TYPE_WORLD_MESH_BLOCK_REQUEST_ML, 1000474008) \ + _(XR_TYPE_WORLD_MESH_GET_INFO_ML, 1000474009) \ + _(XR_TYPE_WORLD_MESH_BLOCK_ML, 1000474010) \ + _(XR_TYPE_WORLD_MESH_REQUEST_COMPLETION_ML, 1000474011) \ + _(XR_TYPE_WORLD_MESH_REQUEST_COMPLETION_INFO_ML, 1000474012) \ + _(XR_TYPE_SYSTEM_FACIAL_EXPRESSION_PROPERTIES_ML, 1000482004) \ + _(XR_TYPE_FACIAL_EXPRESSION_CLIENT_CREATE_INFO_ML, 1000482005) \ + _(XR_TYPE_FACIAL_EXPRESSION_BLEND_SHAPE_GET_INFO_ML, 1000482006) \ + _(XR_TYPE_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_ML, 1000482007) \ + _(XR_TYPE_SYSTEM_BOUNDARY_VISIBILITY_PROPERTIES_META, 1000528000) \ + _(XR_TYPE_EVENT_DATA_BOUNDARY_VISIBILITY_CHANGED_META, 1000528001) \ + _(XR_TYPE_SYSTEM_SIMULTANEOUS_HANDS_AND_CONTROLLERS_PROPERTIES_META, 1000532001) \ + _(XR_TYPE_SIMULTANEOUS_HANDS_AND_CONTROLLERS_TRACKING_RESUME_INFO_META, 1000532002) \ + _(XR_TYPE_SIMULTANEOUS_HANDS_AND_CONTROLLERS_TRACKING_PAUSE_INFO_META, 1000532003) \ + _(XR_TYPE_FACE_TRACKING_VISEMES_META, 1000541000) \ + _(XR_TYPE_SYSTEM_FACE_TRACKING_VISEMES_PROPERTIES_META, 1000541001) \ + _(XR_TYPE_ROOM_MESH_FACE_INDICES_META, 1000553000) \ + _(XR_TYPE_SPACE_ROOM_MESH_GET_INFO_META, 1000553001) \ + _(XR_TYPE_ROOM_MESH_META, 1000553002) \ + _(XR_TYPE_COLOCATION_DISCOVERY_START_INFO_META, 1000571010) \ + _(XR_TYPE_COLOCATION_DISCOVERY_STOP_INFO_META, 1000571011) \ + _(XR_TYPE_COLOCATION_ADVERTISEMENT_START_INFO_META, 1000571012) \ + _(XR_TYPE_COLOCATION_ADVERTISEMENT_STOP_INFO_META, 1000571013) \ + _(XR_TYPE_EVENT_DATA_START_COLOCATION_ADVERTISEMENT_COMPLETE_META, 1000571020) \ + _(XR_TYPE_EVENT_DATA_STOP_COLOCATION_ADVERTISEMENT_COMPLETE_META, 1000571021) \ + _(XR_TYPE_EVENT_DATA_COLOCATION_ADVERTISEMENT_COMPLETE_META, 1000571022) \ + _(XR_TYPE_EVENT_DATA_START_COLOCATION_DISCOVERY_COMPLETE_META, 1000571023) \ + _(XR_TYPE_EVENT_DATA_COLOCATION_DISCOVERY_RESULT_META, 1000571024) \ + _(XR_TYPE_EVENT_DATA_COLOCATION_DISCOVERY_COMPLETE_META, 1000571025) \ + _(XR_TYPE_EVENT_DATA_STOP_COLOCATION_DISCOVERY_COMPLETE_META, 1000571026) \ + _(XR_TYPE_SYSTEM_COLOCATION_DISCOVERY_PROPERTIES_META, 1000571030) \ + _(XR_TYPE_SHARE_SPACES_RECIPIENT_GROUPS_META, 1000572000) \ + _(XR_TYPE_SPACE_GROUP_UUID_FILTER_INFO_META, 1000572001) \ + _(XR_TYPE_SYSTEM_SPATIAL_ENTITY_GROUP_SHARING_PROPERTIES_META, 1000572100) \ + _(XR_TYPE_SYSTEM_ENVIRONMENT_RAYCAST_PROPERTIES_META, 1000592000) \ + _(XR_TYPE_ENVIRONMENT_RAYCASTER_CREATE_INFO_META, 1000592001) \ + _(XR_TYPE_ENVIRONMENT_RAYCASTER_CREATE_COMPLETION_META, 1000592002) \ + _(XR_TYPE_ENVIRONMENT_RAYCAST_HIT_GET_INFO_META, 1000592003) \ + _(XR_TYPE_ENVIRONMENT_RAYCAST_HIT_META, 1000592004) \ + _(XR_TYPE_ENVIRONMENT_RAYCAST_FILTER_DISTANCE_META, 1000592005) \ + _(XR_TYPE_TILE_PROPERTIES_META, 1000609000) \ + _(XR_TYPE_TILE_PROPERTIES_HINT_META, 1000609001) \ + _(XR_TYPE_HAND_TRACKING_UNEXTRAPOLATED_POSES_REQUEST_META, 1000693000) \ + _(XR_TYPE_HAND_TRACKING_UNEXTRAPOLATED_POSES_META, 1000693001) \ + _(XR_TYPE_LIGHT_ESTIMATOR_CREATE_INFO_ANDROID, 1000700000) \ + _(XR_TYPE_LIGHT_ESTIMATE_GET_INFO_ANDROID, 1000700001) \ + _(XR_TYPE_LIGHT_ESTIMATE_ANDROID, 1000700002) \ + _(XR_TYPE_DIRECTIONAL_LIGHT_ANDROID, 1000700003) \ + _(XR_TYPE_SPHERICAL_HARMONICS_ANDROID, 1000700004) \ + _(XR_TYPE_AMBIENT_LIGHT_ANDROID, 1000700005) \ + _(XR_TYPE_SYSTEM_LIGHT_ESTIMATION_PROPERTIES_ANDROID, 1000700006) \ + _(XR_TYPE_ANCHOR_SHARING_INFO_ANDROID, 1000701000) \ + _(XR_TYPE_ANCHOR_SHARING_TOKEN_ANDROID, 1000701001) \ + _(XR_TYPE_SYSTEM_ANCHOR_SHARING_EXPORT_PROPERTIES_ANDROID, 1000701002) \ + _(XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_ANDROID, 1000707000) \ + _(XR_TYPE_TRACKABLE_MARKER_CONFIGURATION_ANDROID, 1000707001) \ + _(XR_TYPE_TRACKABLE_MARKER_ANDROID, 1000707002) \ + _(XR_TYPE_SYSTEM_QR_CODE_TRACKING_PROPERTIES_ANDROID, 1000708000) \ + _(XR_TYPE_TRACKABLE_QR_CODE_CONFIGURATION_ANDROID, 1000708001) \ + _(XR_TYPE_TRACKABLE_QR_CODE_ANDROID, 1000708002) \ + _(XR_TYPE_SYSTEM_IMAGE_TRACKING_PROPERTIES_ANDROID, 1000709000) \ + _(XR_TYPE_TRACKABLE_IMAGE_DATABASE_ENTRY_ANDROID, 1000709001) \ + _(XR_TYPE_TRACKABLE_IMAGE_DATABASE_CREATE_INFO_ANDROID, 1000709002) \ + _(XR_TYPE_CREATE_TRACKABLE_IMAGE_DATABASE_COMPLETION_ANDROID, 1000709003) \ + _(XR_TYPE_TRACKABLE_IMAGE_CONFIGURATION_ANDROID, 1000709004) \ + _(XR_TYPE_TRACKABLE_IMAGE_ANDROID, 1000709005) \ + _(XR_TYPE_EVENT_DATA_IMAGE_TRACKING_LOST_ANDROID, 1000709006) \ + _(XR_TYPE_SYSTEM_SCENE_MESHING_PROPERTIES_ANDROID, 1000718000) \ + _(XR_TYPE_SCENE_MESHING_TRACKER_CREATE_INFO_ANDROID, 1000718001) \ + _(XR_TYPE_SCENE_MESH_SNAPSHOT_CREATE_INFO_ANDROID, 1000718002) \ + _(XR_TYPE_SCENE_MESH_SNAPSHOT_CREATION_RESULT_ANDROID, 1000718003) \ + _(XR_TYPE_SCENE_SUBMESH_STATE_ANDROID, 1000718004) \ + _(XR_TYPE_SCENE_SUBMESH_DATA_ANDROID, 1000718005) \ + _(XR_TYPE_SPATIAL_CAPABILITY_COMPONENT_TYPES_EXT, 1000740000) \ + _(XR_TYPE_SPATIAL_CONTEXT_CREATE_INFO_EXT, 1000740001) \ + _(XR_TYPE_CREATE_SPATIAL_CONTEXT_COMPLETION_EXT, 1000740002) \ + _(XR_TYPE_SPATIAL_DISCOVERY_SNAPSHOT_CREATE_INFO_EXT, 1000740003) \ + _(XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_INFO_EXT, 1000740004) \ + _(XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_EXT, 1000740005) \ + _(XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_CONDITION_EXT, 1000740006) \ + _(XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_RESULT_EXT, 1000740007) \ + _(XR_TYPE_SPATIAL_BUFFER_GET_INFO_EXT, 1000740008) \ + _(XR_TYPE_SPATIAL_COMPONENT_BOUNDED_2D_LIST_EXT, 1000740009) \ + _(XR_TYPE_SPATIAL_COMPONENT_BOUNDED_3D_LIST_EXT, 1000740010) \ + _(XR_TYPE_SPATIAL_COMPONENT_PARENT_LIST_EXT, 1000740011) \ + _(XR_TYPE_SPATIAL_COMPONENT_MESH_3D_LIST_EXT, 1000740012) \ + _(XR_TYPE_SPATIAL_ENTITY_FROM_ID_CREATE_INFO_EXT, 1000740013) \ + _(XR_TYPE_SPATIAL_UPDATE_SNAPSHOT_CREATE_INFO_EXT, 1000740014) \ + _(XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT, 1000740015) \ + _(XR_TYPE_SPATIAL_FILTER_TRACKING_STATE_EXT, 1000740016) \ + _(XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_PLANE_TRACKING_EXT, 1000741000) \ + _(XR_TYPE_SPATIAL_COMPONENT_PLANE_ALIGNMENT_LIST_EXT, 1000741001) \ + _(XR_TYPE_SPATIAL_COMPONENT_MESH_2D_LIST_EXT, 1000741002) \ + _(XR_TYPE_SPATIAL_COMPONENT_POLYGON_2D_LIST_EXT, 1000741003) \ + _(XR_TYPE_SPATIAL_COMPONENT_PLANE_SEMANTIC_LABEL_LIST_EXT, 1000741004) \ + _(XR_TYPE_STATIONARY_REFERENCE_SPACE_GENERATION_ID_GET_INFO_EXT, 1000742001) \ + _(XR_TYPE_STATIONARY_REFERENCE_SPACE_GENERATION_ID_RESULT_EXT, 1000742002) \ + _(XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_QR_CODE_EXT, 1000743000) \ + _(XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_MICRO_QR_CODE_EXT, 1000743001) \ + _(XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ARUCO_MARKER_EXT, 1000743002) \ + _(XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_APRIL_TAG_EXT, 1000743003) \ + _(XR_TYPE_SPATIAL_MARKER_SIZE_EXT, 1000743004) \ + _(XR_TYPE_SPATIAL_MARKER_STATIC_OPTIMIZATION_EXT, 1000743005) \ + _(XR_TYPE_SPATIAL_COMPONENT_MARKER_LIST_EXT, 1000743006) \ + _(XR_TYPE_SYSTEM_DYNAMIC_OBJECT_TRACKING_PROPERTIES_BD, 1000746000) \ + _(XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_DYNAMIC_OBJECT_BD, 1000746001) \ + _(XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_DYNAMIC_OBJECT_BD, 1000746002) \ + _(XR_TYPE_DYNAMIC_OBJECT_DATA_BD, 1000746003) \ + _(XR_TYPE_SENSE_DATA_FILTER_DYNAMIC_OBJECT_TYPE_BD, 1000746004) \ + _(XR_TYPE_SYSTEM_DYNAMIC_OBJECT_KEYBOARD_PROPERTIES_BD, 1000747000) \ + _(XR_TYPE_SYSTEM_DYNAMIC_OBJECT_MOUSE_PROPERTIES_BD, 1000748000) \ + _(XR_TYPE_AVAILABLE_CAMERAS_ENUMERATE_INFO_BD, 1000755000) \ + _(XR_TYPE_CAMERA_PROPERTIES_GET_INFO_BD, 1000755001) \ + _(XR_TYPE_CAMERA_PROPERTIES_BD, 1000755002) \ + _(XR_TYPE_CAMERA_PROPERTY_FACING_BD, 1000755003) \ + _(XR_TYPE_CAMERA_PROPERTY_POSITION_BD, 1000755004) \ + _(XR_TYPE_CAMERA_PROPERTY_CAMERA_TYPE_BD, 1000755005) \ + _(XR_TYPE_CAMERA_SUPPORTED_CAPABILITIES_GET_INFO_BD, 1000755006) \ + _(XR_TYPE_CAMERA_SUPPORTED_CAPABILITIES_BD, 1000755007) \ + _(XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_IMAGE_RESOLUTION_AND_FRAME_RATE_BD, 1000755008) \ + _(XR_TYPE_CAMERA_CAPABILITY_IMAGE_RESOLUTION_AND_FRAME_RATE_BD, 1000755009) \ + _(XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_DATA_TRANSFER_TYPE_BD, 1000755010) \ + _(XR_TYPE_CAMERA_CAPABILITY_DATA_TRANSFER_TYPE_BD, 1000755011) \ + _(XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_IMAGE_FORMAT_BD, 1000755012) \ + _(XR_TYPE_CAMERA_CAPABILITY_IMAGE_FORMAT_BD, 1000755013) \ + _(XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_CAMERA_MODEL_BD, 1000755014) \ + _(XR_TYPE_CAMERA_CAPABILITY_CAMERA_MODEL_BD, 1000755015) \ + _(XR_TYPE_CAMERA_DEVICE_CREATE_INFO_BD, 1000755016) \ + _(XR_TYPE_CREATE_CAMERA_DEVICE_COMPLETION_BD, 1000755017) \ + _(XR_TYPE_CAMERA_CAPTURE_SESSION_CREATE_INFO_BD, 1000755018) \ + _(XR_TYPE_CREATE_CAMERA_CAPTURE_SESSION_COMPLETION_BD, 1000755019) \ + _(XR_TYPE_CAMERA_INTRINSICS_BD, 1000755020) \ + _(XR_TYPE_CAMERA_EXTRINSICS_BD, 1000755021) \ + _(XR_TYPE_CAMERA_CAPTURE_BEGIN_INFO_BD, 1000755022) \ + _(XR_TYPE_CAMERA_IMAGE_ACQUIRE_INFO_BD, 1000755023) \ + _(XR_TYPE_CAMERA_IMAGE_BD, 1000755024) \ + _(XR_TYPE_CAMERA_IMAGE_DATA_RAW_BUFFER_BD, 1000755025) \ + _(XR_TYPE_CAMERA_CAPABILITIES_BD, 1000755026) \ + _(XR_TYPE_CAMERA_CAPABILITY_TYPES_ENUMERATE_INFO_BD, 1000755027) \ + _(XR_TYPE_CAMERA_CAPABILITY_TYPES_BD, 1000755028) \ + _(XR_TYPE_CAMERA_PROPERTY_TYPES_ENUMERATE_INFO_BD, 1000755029) \ + _(XR_TYPE_CAMERA_PROPERTY_TYPES_BD, 1000755030) \ + _(XR_TYPE_AVAILABLE_CAMERA_BD, 1000755031) \ + _(XR_TYPE_SPATIAL_BOUNDS_SPHEREF_ANDROID, 1000761000) \ + _(XR_TYPE_SPATIAL_BOUNDS_BOXF_ANDROID, 1000761001) \ + _(XR_TYPE_SPATIAL_BOUNDS_FRUSTUMF_ANDROID, 1000761002) \ + _(XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ANCHOR_EXT, 1000762000) \ + _(XR_TYPE_SPATIAL_COMPONENT_ANCHOR_LIST_EXT, 1000762001) \ + _(XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_EXT, 1000762002) \ + _(XR_TYPE_SPATIAL_PERSISTENCE_CONTEXT_CREATE_INFO_EXT, 1000763000) \ + _(XR_TYPE_CREATE_SPATIAL_PERSISTENCE_CONTEXT_COMPLETION_EXT, 1000763001) \ + _(XR_TYPE_SPATIAL_CONTEXT_PERSISTENCE_CONFIG_EXT, 1000763002) \ + _(XR_TYPE_SPATIAL_DISCOVERY_PERSISTENCE_UUID_FILTER_EXT, 1000763003) \ + _(XR_TYPE_SPATIAL_COMPONENT_PERSISTENCE_LIST_EXT, 1000763004) \ + _(XR_TYPE_HAPTIC_PARAMETRIC_VIBRATION_EXT, 1000775000) \ + _(XR_TYPE_HAPTIC_PARAMETRIC_PROPERTIES_EXT, 1000775001) \ + _(XR_TYPE_SYSTEM_HAPTIC_PARAMETRIC_PROPERTIES_EXT, 1000775002) \ + _(XR_TYPE_COLOR_SPACES_ENUMERATE_INFO_SONY, 1000776000) \ + _(XR_TYPE_SWAPCHAIN_CREATE_INFO_COLOR_SPACE_SONY, 1000776001) \ + _(XR_TYPE_HDR_METADATA_SONY, 1000777000) \ + _(XR_TYPE_SPATIAL_ENTITY_PERSIST_INFO_EXT, 1000781000) \ + _(XR_TYPE_PERSIST_SPATIAL_ENTITY_COMPLETION_EXT, 1000781001) \ + _(XR_TYPE_SPATIAL_ENTITY_UNPERSIST_INFO_EXT, 1000781002) \ + _(XR_TYPE_UNPERSIST_SPATIAL_ENTITY_COMPLETION_EXT, 1000781003) \ + _(XR_TYPE_SPATIAL_REFERENCE_IMAGE_EXT, 1000782000) \ + _(XR_TYPE_SPATIAL_IMAGE_STATIC_OPTIMIZATION_EXT, 1000782001) \ + _(XR_TYPE_SPATIAL_IMAGE_SIZE_EXT, 1000782002) \ + _(XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_IMAGE_TRACKING_EXT, 1000782003) \ + _(XR_TYPE_SPATIAL_IMAGE_TRACKING_DATABASE_CREATE_INFO_EXT, 1000782004) \ + _(XR_TYPE_SPATIAL_COMPONENT_IMAGE_2D_LIST_EXT, 1000782005) \ + _(XR_TYPE_CREATE_SPATIAL_IMAGE_TRACKING_DATABASE_COMPLETION_EXT, 1000782006) \ + _(XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_OBJECT_TRACKING_ANDROID, 1000785000) \ + _(XR_TYPE_SPATIAL_COMPONENT_OBJECT_SEMANTIC_LABEL_LIST_ANDROID, 1000785001) \ + _(XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_DEPTH_RAYCAST_ANDROID, 1000786000) \ + _(XR_TYPE_SPATIAL_RAYCAST_INFO_ANDROID, 1000786001) \ + _(XR_TYPE_SPATIAL_COMPONENT_RAYCAST_RESULT_LIST_ANDROID, 1000786002) \ + _(XR_TYPE_SPATIAL_RAYCAST_SNAPSHOT_CREATE_INFO_ANDROID, 1000786003) \ + _(XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_API_KEY_ANDROID, 1000787000) \ + _(XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_TOKEN_ANDROID, 1000787001) \ + _(XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_KEYLESS_ANDROID, 1000787002) \ + _(XR_TYPE_GOOGLE_CLOUD_AUTH_ERROR_RESULT_ANDROID, 1000787003) \ + _(XR_TYPE_SYSTEM_GEOSPATIAL_PROPERTIES_ANDROID, 1000789000) \ + _(XR_TYPE_GEOSPATIAL_TRACKER_CREATE_INFO_ANDROID, 1000789001) \ + _(XR_TYPE_EVENT_DATA_GEOSPATIAL_TRACKER_STATE_CHANGED_ANDROID, 1000789002) \ + _(XR_TYPE_GEOSPATIAL_POSE_FROM_POSE_LOCATE_INFO_ANDROID, 1000789003) \ + _(XR_TYPE_GEOSPATIAL_POSE_RESULT_ANDROID, 1000789004) \ + _(XR_TYPE_GEOSPATIAL_POSE_LOCATE_INFO_ANDROID, 1000789005) \ + _(XR_TYPE_VPS_AVAILABILITY_CHECK_COMPLETION_ANDROID, 1000789006) \ + _(XR_TYPE_SPATIAL_ANCHOR_PARENT_ANDROID, 1000790000) \ + _(XR_TYPE_SPATIAL_DISCOVERY_UNIQUE_ENTITIES_FILTER_ANDROID, 1000791001) \ + _(XR_TYPE_SPATIAL_COMPONENT_SUBSUMED_BY_LIST_ANDROID, 1000791002) \ + _(XR_TYPE_SPATIAL_ANCHOR_SPACE_FROM_ID_CREATE_INFO_ANDROID, 1000795000) \ + _(XR_TYPE_GEOSPATIAL_ANCHOR_CREATE_INFO_ANDROID, 1000797000) \ + _(XR_TYPE_SURFACE_ANCHOR_CREATE_INFO_ANDROID, 1000797001) \ + _(XR_TYPE_SURFACE_ANCHOR_CREATE_COMPLETION_ANDROID, 1000797002) \ + _(XR_TYPE_SYSTEM_GEOSPATIAL_ANCHOR_PROPERTIES_ANDROID, 1000797003) \ + _(XR_TYPE_GEOSPATIAL_TRACKER_ANCHOR_TRACKING_INFO_ANDROID, 1000797004) \ + _(XR_TYPE_SPATIAL_CONTAINER_CREATE_INFO_EXT, 1000810000) \ + _(XR_TYPE_SPATIAL_CONTAINER_SPACE_CREATE_INFO_EXT, 1000810001) \ + _(XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_CLOSED_EXT, 1000810003) \ + _(XR_TYPE_SYSTEM_SPATIAL_CONTAINER_PROPERTIES_EXT, 1000810004) \ + _(XR_TYPE_SPATIAL_CONTAINER_BOUNDS_EXT, 1000810005) \ + _(XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_BOUNDS_CHANGED_EXT, 1000810006) \ + _(XR_TYPE_SPATIAL_CONTAINER_BOUNDS_GET_INFO_EXT, 1000810007) \ + _(XR_TYPE_SPATIAL_CONTAINER_STATE_GET_INFO_EXT, 1000810008) \ + _(XR_TYPE_SPATIAL_CONTAINER_VISIBLE_REQUEST_INFO_EXT, 1000810009) \ + _(XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_VISIBLE_CHANGED_EXT, 1000810010) \ + _(XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_VISIBLE_REQUEST_DENIED_EXT, 1000810011) \ + _(XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_INTERACTABLE_CHANGED_EXT, 1000810012) \ + _(XR_TYPE_SPATIAL_CONTAINER_BOUNDS_MODE_REQUEST_INFO_EXT, 1000810013) \ + _(XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_BOUNDS_MODE_REQUEST_DENIED_EXT, 1000810014) \ + _(XR_TYPE_SPATIAL_CONTAINER_STATE_EXT, 1000810015) \ + _(XR_TYPE_SESSION_CREATE_INFO_SPATIAL_CONTAINERS_EXT, 1000810016) \ + _(XR_TYPE_SPATIAL_CONTAINER_VIEW_LOCATE_INFO_EXT, 1000813000) \ + _(XR_TYPE_SPATIAL_CONTAINER_VIEWS_LOCATE_INFO_EXT, 1000813001) \ + _(XR_TYPE_SPATIAL_CONTAINER_VIEW_STATE_EXT, 1000813002) \ + _(XR_TYPE_SPATIAL_CONTAINER_LAYER_EXT, 1000813003) \ + _(XR_TYPE_SPATIAL_CONTAINER_LAYER_FRAME_END_INFO_EXT, 1000813004) \ + _(XR_TYPE_SPATIAL_CONTAINER_BEGIN_INFO_EXT, 1000813005) \ + _(XR_TYPE_SPATIAL_CONTAINER_COMPOSITION_LAYER_VIEW_CONFIGURATION_EXT, 1000813006) \ + _(XR_TYPE_SPATIAL_CONTAINER_END_INFO_EXT, 1000813007) \ + _(XR_TYPE_SPATIAL_CONTAINER_LAYER_VOLUME_CLIPPING_EXT, 1000813008) \ + _(XR_TYPE_BATTERY_STATE_DISPLAY_EXT, 1000836000) \ + _(XR_TYPE_LOADER_INIT_INFO_PROPERTIES_EXT, 1000838000) \ + _(XR_TYPE_EVENT_DATA_VIEW_CONFIGURATION_VIEWS_CHANGED_EXT, 1000839000) \ + _(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_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_XrViewConfigurationType(_) \ + _(XR_VIEW_CONFIGURATION_TYPE_PRIMARY_MONO, 1) \ + _(XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO, 2) \ + _(XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO_WITH_FOVEATED_INSET, 1000037000) \ + _(XR_VIEW_CONFIGURATION_TYPE_SECONDARY_MONO_FIRST_PERSON_OBSERVER_MSFT, 1000054000) \ + _(XR_VIEW_CONFIGURATION_TYPE_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_LOCAL_FLOOR, 1000426000) \ + _(XR_REFERENCE_SPACE_TYPE_UNBOUNDED_MSFT, 1000038000) \ + _(XR_REFERENCE_SPACE_TYPE_COMBINED_EYE_VARJO, 1000121000) \ + _(XR_REFERENCE_SPACE_TYPE_LOCALIZATION_MAP_ML, 1000139000) \ + _(XR_REFERENCE_SPACE_TYPE_UNBOUNDED_ANDROID, 1000467000) \ + _(XR_REFERENCE_SPACE_TYPE_STATIONARY_EXT, 1000742000) \ + _(XR_REFERENCE_SPACE_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_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_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_SPATIAL_GRAPH_NODE_BINDING_MSFT, 1000049000) \ + _(XR_OBJECT_TYPE_HAND_TRACKER_EXT, 1000051000) \ + _(XR_OBJECT_TYPE_BODY_TRACKER_FB, 1000076000) \ + _(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_MARKER_DETECTOR_ML, 1000138000) \ + _(XR_OBJECT_TYPE_EXPORTED_LOCALIZATION_MAP_ML, 1000139000) \ + _(XR_OBJECT_TYPE_SPATIAL_ANCHORS_STORAGE_ML, 1000141000) \ + _(XR_OBJECT_TYPE_SPATIAL_ANCHOR_STORE_CONNECTION_MSFT, 1000142000) \ + _(XR_OBJECT_TYPE_FACE_TRACKER_FB, 1000201000) \ + _(XR_OBJECT_TYPE_EYE_TRACKER_FB, 1000202000) \ + _(XR_OBJECT_TYPE_VIRTUAL_KEYBOARD_META, 1000219000) \ + _(XR_OBJECT_TYPE_SPACE_USER_FB, 1000241000) \ + _(XR_OBJECT_TYPE_PASSTHROUGH_COLOR_LUT_META, 1000266000) \ + _(XR_OBJECT_TYPE_FACE_TRACKER2_FB, 1000287012) \ + _(XR_OBJECT_TYPE_ENVIRONMENT_DEPTH_PROVIDER_META, 1000291000) \ + _(XR_OBJECT_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_META, 1000291001) \ + _(XR_OBJECT_TYPE_RENDER_MODEL_EXT, 1000300000) \ + _(XR_OBJECT_TYPE_RENDER_MODEL_ASSET_EXT, 1000300001) \ + _(XR_OBJECT_TYPE_PASSTHROUGH_HTC, 1000317000) \ + _(XR_OBJECT_TYPE_BODY_TRACKER_HTC, 1000320000) \ + _(XR_OBJECT_TYPE_BODY_TRACKER_BD, 1000385000) \ + _(XR_OBJECT_TYPE_FACE_TRACKER_BD, 1000386000) \ + _(XR_OBJECT_TYPE_SENSE_DATA_PROVIDER_BD, 1000389000) \ + _(XR_OBJECT_TYPE_SENSE_DATA_SNAPSHOT_BD, 1000389001) \ + _(XR_OBJECT_TYPE_ANCHOR_BD, 1000389002) \ + _(XR_OBJECT_TYPE_SPATIAL_AUDIO_RENDERER_BD, 1000409000) \ + _(XR_OBJECT_TYPE_SOUND_FIELD_BD, 1000409001) \ + _(XR_OBJECT_TYPE_SOUND_OBJECT_BD, 1000409002) \ + _(XR_OBJECT_TYPE_SOUND_OBSTACLE_BD, 1000409003) \ + _(XR_OBJECT_TYPE_SOUND_OBSTACLE_MATERIAL_BD, 1000409004) \ + _(XR_OBJECT_TYPE_PLANE_DETECTOR_EXT, 1000429000) \ + _(XR_OBJECT_TYPE_TRACKABLE_TRACKER_ANDROID, 1000455001) \ + _(XR_OBJECT_TYPE_EYE_TRACKER_ANDROID, 1000456000) \ + _(XR_OBJECT_TYPE_DEVICE_ANCHOR_PERSISTENCE_ANDROID, 1000457000) \ + _(XR_OBJECT_TYPE_FACE_TRACKER_ANDROID, 1000458000) \ + _(XR_OBJECT_TYPE_PASSTHROUGH_LAYER_ANDROID, 1000462000) \ + _(XR_OBJECT_TYPE_WORLD_MESH_DETECTOR_ML, 1000474000) \ + _(XR_OBJECT_TYPE_FACIAL_EXPRESSION_CLIENT_ML, 1000482000) \ + _(XR_OBJECT_TYPE_ENVIRONMENT_RAYCASTER_META, 1000592000) \ + _(XR_OBJECT_TYPE_LIGHT_ESTIMATOR_ANDROID, 1000700000) \ + _(XR_OBJECT_TYPE_TRACKABLE_IMAGE_DATABASE_ANDROID, 1000709000) \ + _(XR_OBJECT_TYPE_SCENE_MESHING_TRACKER_ANDROID, 1000718000) \ + _(XR_OBJECT_TYPE_SCENE_MESH_SNAPSHOT_ANDROID, 1000718001) \ + _(XR_OBJECT_TYPE_SPATIAL_ENTITY_EXT, 1000740000) \ + _(XR_OBJECT_TYPE_SPATIAL_CONTEXT_EXT, 1000740001) \ + _(XR_OBJECT_TYPE_SPATIAL_SNAPSHOT_EXT, 1000740002) \ + _(XR_OBJECT_TYPE_CAMERA_DEVICE_BD, 1000755000) \ + _(XR_OBJECT_TYPE_CAMERA_CAPTURE_SESSION_BD, 1000755001) \ + _(XR_OBJECT_TYPE_SPATIAL_PERSISTENCE_CONTEXT_EXT, 1000763000) \ + _(XR_OBJECT_TYPE_SPATIAL_IMAGE_TRACKING_DATABASE_EXT, 1000782000) \ + _(XR_OBJECT_TYPE_GEOSPATIAL_TRACKER_ANDROID, 1000789000) \ + _(XR_OBJECT_TYPE_SPATIAL_CONTAINER_EXT, 1000810000) \ + _(XR_OBJECT_TYPE_MAX_ENUM, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrLoaderInterfaceStructs(_) \ + _(XR_LOADER_INTERFACE_STRUCT_UNINTIALIZED, 0) \ + _(XR_LOADER_INTERFACE_STRUCT_LOADER_INFO, 1) \ + _(XR_LOADER_INTERFACE_STRUCT_API_LAYER_REQUEST, 2) \ + _(XR_LOADER_INTERFACE_STRUCT_RUNTIME_REQUEST, 3) \ + _(XR_LOADER_INTERFACE_STRUCT_API_LAYER_CREATE_INFO, 4) \ + _(XR_LOADER_INTERFACE_STRUCT_API_LAYER_NEXT_INFO, 5) \ + _(XR_LOADER_INTERFACE_STRUCTS_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_HAND_WITH_FOREARM_ULTRALEAP, 1000149000) \ + _(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_XrBodyJointFB(_) \ + _(XR_BODY_JOINT_ROOT_FB, 0) \ + _(XR_BODY_JOINT_HIPS_FB, 1) \ + _(XR_BODY_JOINT_SPINE_LOWER_FB, 2) \ + _(XR_BODY_JOINT_SPINE_MIDDLE_FB, 3) \ + _(XR_BODY_JOINT_SPINE_UPPER_FB, 4) \ + _(XR_BODY_JOINT_CHEST_FB, 5) \ + _(XR_BODY_JOINT_NECK_FB, 6) \ + _(XR_BODY_JOINT_HEAD_FB, 7) \ + _(XR_BODY_JOINT_LEFT_SHOULDER_FB, 8) \ + _(XR_BODY_JOINT_LEFT_SCAPULA_FB, 9) \ + _(XR_BODY_JOINT_LEFT_ARM_UPPER_FB, 10) \ + _(XR_BODY_JOINT_LEFT_ARM_LOWER_FB, 11) \ + _(XR_BODY_JOINT_LEFT_HAND_WRIST_TWIST_FB, 12) \ + _(XR_BODY_JOINT_RIGHT_SHOULDER_FB, 13) \ + _(XR_BODY_JOINT_RIGHT_SCAPULA_FB, 14) \ + _(XR_BODY_JOINT_RIGHT_ARM_UPPER_FB, 15) \ + _(XR_BODY_JOINT_RIGHT_ARM_LOWER_FB, 16) \ + _(XR_BODY_JOINT_RIGHT_HAND_WRIST_TWIST_FB, 17) \ + _(XR_BODY_JOINT_LEFT_HAND_PALM_FB, 18) \ + _(XR_BODY_JOINT_LEFT_HAND_WRIST_FB, 19) \ + _(XR_BODY_JOINT_LEFT_HAND_THUMB_METACARPAL_FB, 20) \ + _(XR_BODY_JOINT_LEFT_HAND_THUMB_PROXIMAL_FB, 21) \ + _(XR_BODY_JOINT_LEFT_HAND_THUMB_DISTAL_FB, 22) \ + _(XR_BODY_JOINT_LEFT_HAND_THUMB_TIP_FB, 23) \ + _(XR_BODY_JOINT_LEFT_HAND_INDEX_METACARPAL_FB, 24) \ + _(XR_BODY_JOINT_LEFT_HAND_INDEX_PROXIMAL_FB, 25) \ + _(XR_BODY_JOINT_LEFT_HAND_INDEX_INTERMEDIATE_FB, 26) \ + _(XR_BODY_JOINT_LEFT_HAND_INDEX_DISTAL_FB, 27) \ + _(XR_BODY_JOINT_LEFT_HAND_INDEX_TIP_FB, 28) \ + _(XR_BODY_JOINT_LEFT_HAND_MIDDLE_METACARPAL_FB, 29) \ + _(XR_BODY_JOINT_LEFT_HAND_MIDDLE_PROXIMAL_FB, 30) \ + _(XR_BODY_JOINT_LEFT_HAND_MIDDLE_INTERMEDIATE_FB, 31) \ + _(XR_BODY_JOINT_LEFT_HAND_MIDDLE_DISTAL_FB, 32) \ + _(XR_BODY_JOINT_LEFT_HAND_MIDDLE_TIP_FB, 33) \ + _(XR_BODY_JOINT_LEFT_HAND_RING_METACARPAL_FB, 34) \ + _(XR_BODY_JOINT_LEFT_HAND_RING_PROXIMAL_FB, 35) \ + _(XR_BODY_JOINT_LEFT_HAND_RING_INTERMEDIATE_FB, 36) \ + _(XR_BODY_JOINT_LEFT_HAND_RING_DISTAL_FB, 37) \ + _(XR_BODY_JOINT_LEFT_HAND_RING_TIP_FB, 38) \ + _(XR_BODY_JOINT_LEFT_HAND_LITTLE_METACARPAL_FB, 39) \ + _(XR_BODY_JOINT_LEFT_HAND_LITTLE_PROXIMAL_FB, 40) \ + _(XR_BODY_JOINT_LEFT_HAND_LITTLE_INTERMEDIATE_FB, 41) \ + _(XR_BODY_JOINT_LEFT_HAND_LITTLE_DISTAL_FB, 42) \ + _(XR_BODY_JOINT_LEFT_HAND_LITTLE_TIP_FB, 43) \ + _(XR_BODY_JOINT_RIGHT_HAND_PALM_FB, 44) \ + _(XR_BODY_JOINT_RIGHT_HAND_WRIST_FB, 45) \ + _(XR_BODY_JOINT_RIGHT_HAND_THUMB_METACARPAL_FB, 46) \ + _(XR_BODY_JOINT_RIGHT_HAND_THUMB_PROXIMAL_FB, 47) \ + _(XR_BODY_JOINT_RIGHT_HAND_THUMB_DISTAL_FB, 48) \ + _(XR_BODY_JOINT_RIGHT_HAND_THUMB_TIP_FB, 49) \ + _(XR_BODY_JOINT_RIGHT_HAND_INDEX_METACARPAL_FB, 50) \ + _(XR_BODY_JOINT_RIGHT_HAND_INDEX_PROXIMAL_FB, 51) \ + _(XR_BODY_JOINT_RIGHT_HAND_INDEX_INTERMEDIATE_FB, 52) \ + _(XR_BODY_JOINT_RIGHT_HAND_INDEX_DISTAL_FB, 53) \ + _(XR_BODY_JOINT_RIGHT_HAND_INDEX_TIP_FB, 54) \ + _(XR_BODY_JOINT_RIGHT_HAND_MIDDLE_METACARPAL_FB, 55) \ + _(XR_BODY_JOINT_RIGHT_HAND_MIDDLE_PROXIMAL_FB, 56) \ + _(XR_BODY_JOINT_RIGHT_HAND_MIDDLE_INTERMEDIATE_FB, 57) \ + _(XR_BODY_JOINT_RIGHT_HAND_MIDDLE_DISTAL_FB, 58) \ + _(XR_BODY_JOINT_RIGHT_HAND_MIDDLE_TIP_FB, 59) \ + _(XR_BODY_JOINT_RIGHT_HAND_RING_METACARPAL_FB, 60) \ + _(XR_BODY_JOINT_RIGHT_HAND_RING_PROXIMAL_FB, 61) \ + _(XR_BODY_JOINT_RIGHT_HAND_RING_INTERMEDIATE_FB, 62) \ + _(XR_BODY_JOINT_RIGHT_HAND_RING_DISTAL_FB, 63) \ + _(XR_BODY_JOINT_RIGHT_HAND_RING_TIP_FB, 64) \ + _(XR_BODY_JOINT_RIGHT_HAND_LITTLE_METACARPAL_FB, 65) \ + _(XR_BODY_JOINT_RIGHT_HAND_LITTLE_PROXIMAL_FB, 66) \ + _(XR_BODY_JOINT_RIGHT_HAND_LITTLE_INTERMEDIATE_FB, 67) \ + _(XR_BODY_JOINT_RIGHT_HAND_LITTLE_DISTAL_FB, 68) \ + _(XR_BODY_JOINT_RIGHT_HAND_LITTLE_TIP_FB, 69) \ + _(XR_BODY_JOINT_COUNT_FB, 70) \ + _(XR_BODY_JOINT_NONE_FB, -1) \ + _(XR_BODY_JOINT_MAX_ENUM_FB, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrBodyJointSetFB(_) \ + _(XR_BODY_JOINT_SET_DEFAULT_FB, 0) \ + _(XR_BODY_JOINT_SET_FULL_BODY_META, 1000274000) \ + _(XR_BODY_JOINT_SET_MAX_ENUM_FB, 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_MARKER_MSFT, 1000147000) \ + _(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_MARKER_MSFT, 1000147000) \ + _(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_RAISER_RIGHT_HTC, 12) \ + _(XR_LIP_EXPRESSION_MOUTH_RAISER_LEFT_HTC, 13) \ + _(XR_LIP_EXPRESSION_MOUTH_STRETCHER_RIGHT_HTC, 14) \ + _(XR_LIP_EXPRESSION_MOUTH_STRETCHER_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_XrSpaceComponentTypeFB(_) \ + _(XR_SPACE_COMPONENT_TYPE_LOCATABLE_FB, 0) \ + _(XR_SPACE_COMPONENT_TYPE_STORABLE_FB, 1) \ + _(XR_SPACE_COMPONENT_TYPE_SHARABLE_FB, 2) \ + _(XR_SPACE_COMPONENT_TYPE_BOUNDED_2D_FB, 3) \ + _(XR_SPACE_COMPONENT_TYPE_BOUNDED_3D_FB, 4) \ + _(XR_SPACE_COMPONENT_TYPE_SEMANTIC_LABELS_FB, 5) \ + _(XR_SPACE_COMPONENT_TYPE_ROOM_LAYOUT_FB, 6) \ + _(XR_SPACE_COMPONENT_TYPE_SPACE_CONTAINER_FB, 7) \ + _(XR_SPACE_COMPONENT_TYPE_TRIANGLE_MESH_META, 1000269000) \ + _(XR_SPACE_COMPONENT_TYPE_ROOM_MESH_META, 1000553000) \ + _(XR_SPACE_COMPONENT_TYPE_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_TRACKED_KEYBOARD_MASKED_HANDS_FB, 1000203002) \ + _(XR_PASSTHROUGH_LAYER_PURPOSE_MAX_ENUM_FB, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrMarkerDetectorProfileML(_) \ + _(XR_MARKER_DETECTOR_PROFILE_DEFAULT_ML, 0) \ + _(XR_MARKER_DETECTOR_PROFILE_SPEED_ML, 1) \ + _(XR_MARKER_DETECTOR_PROFILE_ACCURACY_ML, 2) \ + _(XR_MARKER_DETECTOR_PROFILE_SMALL_TARGETS_ML, 3) \ + _(XR_MARKER_DETECTOR_PROFILE_LARGE_FOV_ML, 4) \ + _(XR_MARKER_DETECTOR_PROFILE_CUSTOM_ML, 5) \ + _(XR_MARKER_DETECTOR_PROFILE_MAX_ENUM_ML, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrMarkerTypeML(_) \ + _(XR_MARKER_TYPE_ARUCO_ML, 0) \ + _(XR_MARKER_TYPE_APRIL_TAG_ML, 1) \ + _(XR_MARKER_TYPE_QR_ML, 2) \ + _(XR_MARKER_TYPE_EAN_13_ML, 3) \ + _(XR_MARKER_TYPE_UPC_A_ML, 4) \ + _(XR_MARKER_TYPE_CODE_128_ML, 5) \ + _(XR_MARKER_TYPE_MAX_ENUM_ML, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrMarkerArucoDictML(_) \ + _(XR_MARKER_ARUCO_DICT_4X4_50_ML, 0) \ + _(XR_MARKER_ARUCO_DICT_4X4_100_ML, 1) \ + _(XR_MARKER_ARUCO_DICT_4X4_250_ML, 2) \ + _(XR_MARKER_ARUCO_DICT_4X4_1000_ML, 3) \ + _(XR_MARKER_ARUCO_DICT_5X5_50_ML, 4) \ + _(XR_MARKER_ARUCO_DICT_5X5_100_ML, 5) \ + _(XR_MARKER_ARUCO_DICT_5X5_250_ML, 6) \ + _(XR_MARKER_ARUCO_DICT_5X5_1000_ML, 7) \ + _(XR_MARKER_ARUCO_DICT_6X6_50_ML, 8) \ + _(XR_MARKER_ARUCO_DICT_6X6_100_ML, 9) \ + _(XR_MARKER_ARUCO_DICT_6X6_250_ML, 10) \ + _(XR_MARKER_ARUCO_DICT_6X6_1000_ML, 11) \ + _(XR_MARKER_ARUCO_DICT_7X7_50_ML, 12) \ + _(XR_MARKER_ARUCO_DICT_7X7_100_ML, 13) \ + _(XR_MARKER_ARUCO_DICT_7X7_250_ML, 14) \ + _(XR_MARKER_ARUCO_DICT_7X7_1000_ML, 15) \ + _(XR_MARKER_ARUCO_DICT_MAX_ENUM_ML, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrMarkerAprilTagDictML(_) \ + _(XR_MARKER_APRIL_TAG_DICT_16H5_ML, 0) \ + _(XR_MARKER_APRIL_TAG_DICT_25H9_ML, 1) \ + _(XR_MARKER_APRIL_TAG_DICT_36H10_ML, 2) \ + _(XR_MARKER_APRIL_TAG_DICT_36H11_ML, 3) \ + _(XR_MARKER_APRIL_TAG_DICT_MAX_ENUM_ML, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrMarkerDetectorFpsML(_) \ + _(XR_MARKER_DETECTOR_FPS_LOW_ML, 0) \ + _(XR_MARKER_DETECTOR_FPS_MEDIUM_ML, 1) \ + _(XR_MARKER_DETECTOR_FPS_HIGH_ML, 2) \ + _(XR_MARKER_DETECTOR_FPS_MAX_ML, 3) \ + _(XR_MARKER_DETECTOR_FPS_MAX_ENUM_ML, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrMarkerDetectorResolutionML(_) \ + _(XR_MARKER_DETECTOR_RESOLUTION_LOW_ML, 0) \ + _(XR_MARKER_DETECTOR_RESOLUTION_MEDIUM_ML, 1) \ + _(XR_MARKER_DETECTOR_RESOLUTION_HIGH_ML, 2) \ + _(XR_MARKER_DETECTOR_RESOLUTION_MAX_ENUM_ML, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrMarkerDetectorCameraML(_) \ + _(XR_MARKER_DETECTOR_CAMERA_RGB_CAMERA_ML, 0) \ + _(XR_MARKER_DETECTOR_CAMERA_WORLD_CAMERAS_ML, 1) \ + _(XR_MARKER_DETECTOR_CAMERA_MAX_ENUM_ML, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrMarkerDetectorCornerRefineMethodML(_) \ + _(XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_NONE_ML, 0) \ + _(XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_SUBPIX_ML, 1) \ + _(XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_CONTOUR_ML, 2) \ + _(XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_APRIL_TAG_ML, 3) \ + _(XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_MAX_ENUM_ML, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrMarkerDetectorFullAnalysisIntervalML(_) \ + _(XR_MARKER_DETECTOR_FULL_ANALYSIS_INTERVAL_MAX_ML, 0) \ + _(XR_MARKER_DETECTOR_FULL_ANALYSIS_INTERVAL_FAST_ML, 1) \ + _(XR_MARKER_DETECTOR_FULL_ANALYSIS_INTERVAL_MEDIUM_ML, 2) \ + _(XR_MARKER_DETECTOR_FULL_ANALYSIS_INTERVAL_SLOW_ML, 3) \ + _(XR_MARKER_DETECTOR_FULL_ANALYSIS_INTERVAL_MAX_ENUM_ML, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrMarkerDetectorStatusML(_) \ + _(XR_MARKER_DETECTOR_STATUS_PENDING_ML, 0) \ + _(XR_MARKER_DETECTOR_STATUS_READY_ML, 1) \ + _(XR_MARKER_DETECTOR_STATUS_ERROR_ML, 2) \ + _(XR_MARKER_DETECTOR_STATUS_MAX_ENUM_ML, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrLocalizationMapStateML(_) \ + _(XR_LOCALIZATION_MAP_STATE_NOT_LOCALIZED_ML, 0) \ + _(XR_LOCALIZATION_MAP_STATE_LOCALIZED_ML, 1) \ + _(XR_LOCALIZATION_MAP_STATE_LOCALIZATION_PENDING_ML, 2) \ + _(XR_LOCALIZATION_MAP_STATE_LOCALIZATION_SLEEPING_BEFORE_RETRY_ML, 3) \ + _(XR_LOCALIZATION_MAP_STATE_MAX_ENUM_ML, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrLocalizationMapTypeML(_) \ + _(XR_LOCALIZATION_MAP_TYPE_ON_DEVICE_ML, 0) \ + _(XR_LOCALIZATION_MAP_TYPE_CLOUD_ML, 1) \ + _(XR_LOCALIZATION_MAP_TYPE_MAX_ENUM_ML, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrLocalizationMapConfidenceML(_) \ + _(XR_LOCALIZATION_MAP_CONFIDENCE_POOR_ML, 0) \ + _(XR_LOCALIZATION_MAP_CONFIDENCE_FAIR_ML, 1) \ + _(XR_LOCALIZATION_MAP_CONFIDENCE_GOOD_ML, 2) \ + _(XR_LOCALIZATION_MAP_CONFIDENCE_EXCELLENT_ML, 3) \ + _(XR_LOCALIZATION_MAP_CONFIDENCE_MAX_ENUM_ML, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpatialAnchorConfidenceML(_) \ + _(XR_SPATIAL_ANCHOR_CONFIDENCE_LOW_ML, 0) \ + _(XR_SPATIAL_ANCHOR_CONFIDENCE_MEDIUM_ML, 1) \ + _(XR_SPATIAL_ANCHOR_CONFIDENCE_HIGH_ML, 2) \ + _(XR_SPATIAL_ANCHOR_CONFIDENCE_MAX_ENUM_ML, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSceneMarkerTypeMSFT(_) \ + _(XR_SCENE_MARKER_TYPE_QR_CODE_MSFT, 1) \ + _(XR_SCENE_MARKER_TYPE_MAX_ENUM_MSFT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSceneMarkerQRCodeSymbolTypeMSFT(_) \ + _(XR_SCENE_MARKER_QR_CODE_SYMBOL_TYPE_QR_CODE_MSFT, 1) \ + _(XR_SCENE_MARKER_QR_CODE_SYMBOL_TYPE_MICRO_QR_CODE_MSFT, 2) \ + _(XR_SCENE_MARKER_QRCODE_SYMBOL_TYPE_MAX_ENUM_MSFT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrHandForearmJointULTRALEAP(_) \ + _(XR_HAND_FOREARM_JOINT_PALM_ULTRALEAP, 0) \ + _(XR_HAND_FOREARM_JOINT_WRIST_ULTRALEAP, 1) \ + _(XR_HAND_FOREARM_JOINT_THUMB_METACARPAL_ULTRALEAP, 2) \ + _(XR_HAND_FOREARM_JOINT_THUMB_PROXIMAL_ULTRALEAP, 3) \ + _(XR_HAND_FOREARM_JOINT_THUMB_DISTAL_ULTRALEAP, 4) \ + _(XR_HAND_FOREARM_JOINT_THUMB_TIP_ULTRALEAP, 5) \ + _(XR_HAND_FOREARM_JOINT_INDEX_METACARPAL_ULTRALEAP, 6) \ + _(XR_HAND_FOREARM_JOINT_INDEX_PROXIMAL_ULTRALEAP, 7) \ + _(XR_HAND_FOREARM_JOINT_INDEX_INTERMEDIATE_ULTRALEAP, 8) \ + _(XR_HAND_FOREARM_JOINT_INDEX_DISTAL_ULTRALEAP, 9) \ + _(XR_HAND_FOREARM_JOINT_INDEX_TIP_ULTRALEAP, 10) \ + _(XR_HAND_FOREARM_JOINT_MIDDLE_METACARPAL_ULTRALEAP, 11) \ + _(XR_HAND_FOREARM_JOINT_MIDDLE_PROXIMAL_ULTRALEAP, 12) \ + _(XR_HAND_FOREARM_JOINT_MIDDLE_INTERMEDIATE_ULTRALEAP, 13) \ + _(XR_HAND_FOREARM_JOINT_MIDDLE_DISTAL_ULTRALEAP, 14) \ + _(XR_HAND_FOREARM_JOINT_MIDDLE_TIP_ULTRALEAP, 15) \ + _(XR_HAND_FOREARM_JOINT_RING_METACARPAL_ULTRALEAP, 16) \ + _(XR_HAND_FOREARM_JOINT_RING_PROXIMAL_ULTRALEAP, 17) \ + _(XR_HAND_FOREARM_JOINT_RING_INTERMEDIATE_ULTRALEAP, 18) \ + _(XR_HAND_FOREARM_JOINT_RING_DISTAL_ULTRALEAP, 19) \ + _(XR_HAND_FOREARM_JOINT_RING_TIP_ULTRALEAP, 20) \ + _(XR_HAND_FOREARM_JOINT_LITTLE_METACARPAL_ULTRALEAP, 21) \ + _(XR_HAND_FOREARM_JOINT_LITTLE_PROXIMAL_ULTRALEAP, 22) \ + _(XR_HAND_FOREARM_JOINT_LITTLE_INTERMEDIATE_ULTRALEAP, 23) \ + _(XR_HAND_FOREARM_JOINT_LITTLE_DISTAL_ULTRALEAP, 24) \ + _(XR_HAND_FOREARM_JOINT_LITTLE_TIP_ULTRALEAP, 25) \ + _(XR_HAND_FOREARM_JOINT_ELBOW_ULTRALEAP, 26) \ + _(XR_HAND_FOREARM_JOINT_MAX_ENUM_ULTRALEAP, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpaceQueryActionFB(_) \ + _(XR_SPACE_QUERY_ACTION_LOAD_FB, 0) \ + _(XR_SPACE_QUERY_ACTION_MAX_ENUM_FB, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpaceStorageLocationFB(_) \ + _(XR_SPACE_STORAGE_LOCATION_INVALID_FB, 0) \ + _(XR_SPACE_STORAGE_LOCATION_LOCAL_FB, 1) \ + _(XR_SPACE_STORAGE_LOCATION_CLOUD_FB, 2) \ + _(XR_SPACE_STORAGE_LOCATION_MAX_ENUM_FB, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpacePersistenceModeFB(_) \ + _(XR_SPACE_PERSISTENCE_MODE_INVALID_FB, 0) \ + _(XR_SPACE_PERSISTENCE_MODE_INDEFINITE_FB, 1) \ + _(XR_SPACE_PERSISTENCE_MODE_MAX_ENUM_FB, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrFaceExpressionFB(_) \ + _(XR_FACE_EXPRESSION_BROW_LOWERER_L_FB, 0) \ + _(XR_FACE_EXPRESSION_BROW_LOWERER_R_FB, 1) \ + _(XR_FACE_EXPRESSION_CHEEK_PUFF_L_FB, 2) \ + _(XR_FACE_EXPRESSION_CHEEK_PUFF_R_FB, 3) \ + _(XR_FACE_EXPRESSION_CHEEK_RAISER_L_FB, 4) \ + _(XR_FACE_EXPRESSION_CHEEK_RAISER_R_FB, 5) \ + _(XR_FACE_EXPRESSION_CHEEK_SUCK_L_FB, 6) \ + _(XR_FACE_EXPRESSION_CHEEK_SUCK_R_FB, 7) \ + _(XR_FACE_EXPRESSION_CHIN_RAISER_B_FB, 8) \ + _(XR_FACE_EXPRESSION_CHIN_RAISER_T_FB, 9) \ + _(XR_FACE_EXPRESSION_DIMPLER_L_FB, 10) \ + _(XR_FACE_EXPRESSION_DIMPLER_R_FB, 11) \ + _(XR_FACE_EXPRESSION_EYES_CLOSED_L_FB, 12) \ + _(XR_FACE_EXPRESSION_EYES_CLOSED_R_FB, 13) \ + _(XR_FACE_EXPRESSION_EYES_LOOK_DOWN_L_FB, 14) \ + _(XR_FACE_EXPRESSION_EYES_LOOK_DOWN_R_FB, 15) \ + _(XR_FACE_EXPRESSION_EYES_LOOK_LEFT_L_FB, 16) \ + _(XR_FACE_EXPRESSION_EYES_LOOK_LEFT_R_FB, 17) \ + _(XR_FACE_EXPRESSION_EYES_LOOK_RIGHT_L_FB, 18) \ + _(XR_FACE_EXPRESSION_EYES_LOOK_RIGHT_R_FB, 19) \ + _(XR_FACE_EXPRESSION_EYES_LOOK_UP_L_FB, 20) \ + _(XR_FACE_EXPRESSION_EYES_LOOK_UP_R_FB, 21) \ + _(XR_FACE_EXPRESSION_INNER_BROW_RAISER_L_FB, 22) \ + _(XR_FACE_EXPRESSION_INNER_BROW_RAISER_R_FB, 23) \ + _(XR_FACE_EXPRESSION_JAW_DROP_FB, 24) \ + _(XR_FACE_EXPRESSION_JAW_SIDEWAYS_LEFT_FB, 25) \ + _(XR_FACE_EXPRESSION_JAW_SIDEWAYS_RIGHT_FB, 26) \ + _(XR_FACE_EXPRESSION_JAW_THRUST_FB, 27) \ + _(XR_FACE_EXPRESSION_LID_TIGHTENER_L_FB, 28) \ + _(XR_FACE_EXPRESSION_LID_TIGHTENER_R_FB, 29) \ + _(XR_FACE_EXPRESSION_LIP_CORNER_DEPRESSOR_L_FB, 30) \ + _(XR_FACE_EXPRESSION_LIP_CORNER_DEPRESSOR_R_FB, 31) \ + _(XR_FACE_EXPRESSION_LIP_CORNER_PULLER_L_FB, 32) \ + _(XR_FACE_EXPRESSION_LIP_CORNER_PULLER_R_FB, 33) \ + _(XR_FACE_EXPRESSION_LIP_FUNNELER_LB_FB, 34) \ + _(XR_FACE_EXPRESSION_LIP_FUNNELER_LT_FB, 35) \ + _(XR_FACE_EXPRESSION_LIP_FUNNELER_RB_FB, 36) \ + _(XR_FACE_EXPRESSION_LIP_FUNNELER_RT_FB, 37) \ + _(XR_FACE_EXPRESSION_LIP_PRESSOR_L_FB, 38) \ + _(XR_FACE_EXPRESSION_LIP_PRESSOR_R_FB, 39) \ + _(XR_FACE_EXPRESSION_LIP_PUCKER_L_FB, 40) \ + _(XR_FACE_EXPRESSION_LIP_PUCKER_R_FB, 41) \ + _(XR_FACE_EXPRESSION_LIP_STRETCHER_L_FB, 42) \ + _(XR_FACE_EXPRESSION_LIP_STRETCHER_R_FB, 43) \ + _(XR_FACE_EXPRESSION_LIP_SUCK_LB_FB, 44) \ + _(XR_FACE_EXPRESSION_LIP_SUCK_LT_FB, 45) \ + _(XR_FACE_EXPRESSION_LIP_SUCK_RB_FB, 46) \ + _(XR_FACE_EXPRESSION_LIP_SUCK_RT_FB, 47) \ + _(XR_FACE_EXPRESSION_LIP_TIGHTENER_L_FB, 48) \ + _(XR_FACE_EXPRESSION_LIP_TIGHTENER_R_FB, 49) \ + _(XR_FACE_EXPRESSION_LIPS_TOWARD_FB, 50) \ + _(XR_FACE_EXPRESSION_LOWER_LIP_DEPRESSOR_L_FB, 51) \ + _(XR_FACE_EXPRESSION_LOWER_LIP_DEPRESSOR_R_FB, 52) \ + _(XR_FACE_EXPRESSION_MOUTH_LEFT_FB, 53) \ + _(XR_FACE_EXPRESSION_MOUTH_RIGHT_FB, 54) \ + _(XR_FACE_EXPRESSION_NOSE_WRINKLER_L_FB, 55) \ + _(XR_FACE_EXPRESSION_NOSE_WRINKLER_R_FB, 56) \ + _(XR_FACE_EXPRESSION_OUTER_BROW_RAISER_L_FB, 57) \ + _(XR_FACE_EXPRESSION_OUTER_BROW_RAISER_R_FB, 58) \ + _(XR_FACE_EXPRESSION_UPPER_LID_RAISER_L_FB, 59) \ + _(XR_FACE_EXPRESSION_UPPER_LID_RAISER_R_FB, 60) \ + _(XR_FACE_EXPRESSION_UPPER_LIP_RAISER_L_FB, 61) \ + _(XR_FACE_EXPRESSION_UPPER_LIP_RAISER_R_FB, 62) \ + _(XR_FACE_EXPRESSION_COUNT_FB, 63) \ + _(XR_FACE_EXPRESSION_MAX_ENUM_FB, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrFaceExpressionSetFB(_) \ + _(XR_FACE_EXPRESSION_SET_DEFAULT_FB, 0) \ + _(XR_FACE_EXPRESSION_SET_MAX_ENUM_FB, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrFaceConfidenceFB(_) \ + _(XR_FACE_CONFIDENCE_LOWER_FACE_FB, 0) \ + _(XR_FACE_CONFIDENCE_UPPER_FACE_FB, 1) \ + _(XR_FACE_CONFIDENCE_COUNT_FB, 2) \ + _(XR_FACE_CONFIDENCE_MAX_ENUM_FB, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrEyePositionFB(_) \ + _(XR_EYE_POSITION_LEFT_FB, 0) \ + _(XR_EYE_POSITION_RIGHT_FB, 1) \ + _(XR_EYE_POSITION_COUNT_FB, 2) \ + _(XR_EYE_POSITION_MAX_ENUM_FB, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrCompareOpFB(_) \ + _(XR_COMPARE_OP_NEVER_FB, 0) \ + _(XR_COMPARE_OP_LESS_FB, 1) \ + _(XR_COMPARE_OP_EQUAL_FB, 2) \ + _(XR_COMPARE_OP_LESS_OR_EQUAL_FB, 3) \ + _(XR_COMPARE_OP_GREATER_FB, 4) \ + _(XR_COMPARE_OP_NOT_EQUAL_FB, 5) \ + _(XR_COMPARE_OP_GREATER_OR_EQUAL_FB, 6) \ + _(XR_COMPARE_OP_ALWAYS_FB, 7) \ + _(XR_COMPARE_OPFB_MAX_ENUM_FB, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrLocalDimmingModeMETA(_) \ + _(XR_LOCAL_DIMMING_MODE_OFF_META, 0) \ + _(XR_LOCAL_DIMMING_MODE_ON_META, 1) \ + _(XR_LOCAL_DIMMING_MODE_MAX_ENUM_META, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrVirtualKeyboardLocationTypeMETA(_) \ + _(XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_CUSTOM_META, 0) \ + _(XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_FAR_META, 1) \ + _(XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_DIRECT_META, 2) \ + _(XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_MAX_ENUM_META, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrVirtualKeyboardInputSourceMETA(_) \ + _(XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_RAY_LEFT_META, 1) \ + _(XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_RAY_RIGHT_META, 2) \ + _(XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_RAY_LEFT_META, 3) \ + _(XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_RAY_RIGHT_META, 4) \ + _(XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_DIRECT_LEFT_META, 5) \ + _(XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_DIRECT_RIGHT_META, 6) \ + _(XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_DIRECT_INDEX_TIP_LEFT_META, 7) \ + _(XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_DIRECT_INDEX_TIP_RIGHT_META, 8) \ + _(XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_MAX_ENUM_META, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrExternalCameraAttachedToDeviceOCULUS(_) \ + _(XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_NONE_OCULUS, 0) \ + _(XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_HMD_OCULUS, 1) \ + _(XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_LTOUCH_OCULUS, 2) \ + _(XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_RTOUCH_OCULUS, 3) \ + _(XR_EXTERNAL_CAMERA_ATTACHED_TODEVICE_MAX_ENUM_OCULUS, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrPerformanceMetricsCounterUnitMETA(_) \ + _(XR_PERFORMANCE_METRICS_COUNTER_UNIT_GENERIC_META, 0) \ + _(XR_PERFORMANCE_METRICS_COUNTER_UNIT_PERCENTAGE_META, 1) \ + _(XR_PERFORMANCE_METRICS_COUNTER_UNIT_MILLISECONDS_META, 2) \ + _(XR_PERFORMANCE_METRICS_COUNTER_UNIT_BYTES_META, 3) \ + _(XR_PERFORMANCE_METRICS_COUNTER_UNIT_HERTZ_META, 4) \ + _(XR_PERFORMANCE_METRICS_COUNTER_UNIT_MAX_ENUM_META, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrPassthroughColorLutChannelsMETA(_) \ + _(XR_PASSTHROUGH_COLOR_LUT_CHANNELS_RGB_META, 1) \ + _(XR_PASSTHROUGH_COLOR_LUT_CHANNELS_RGBA_META, 2) \ + _(XR_PASSTHROUGH_COLOR_LUT_CHANNELS_MAX_ENUM_META, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrFullBodyJointMETA(_) \ + _(XR_FULL_BODY_JOINT_ROOT_META, 0) \ + _(XR_FULL_BODY_JOINT_HIPS_META, 1) \ + _(XR_FULL_BODY_JOINT_SPINE_LOWER_META, 2) \ + _(XR_FULL_BODY_JOINT_SPINE_MIDDLE_META, 3) \ + _(XR_FULL_BODY_JOINT_SPINE_UPPER_META, 4) \ + _(XR_FULL_BODY_JOINT_CHEST_META, 5) \ + _(XR_FULL_BODY_JOINT_NECK_META, 6) \ + _(XR_FULL_BODY_JOINT_HEAD_META, 7) \ + _(XR_FULL_BODY_JOINT_LEFT_SHOULDER_META, 8) \ + _(XR_FULL_BODY_JOINT_LEFT_SCAPULA_META, 9) \ + _(XR_FULL_BODY_JOINT_LEFT_ARM_UPPER_META, 10) \ + _(XR_FULL_BODY_JOINT_LEFT_ARM_LOWER_META, 11) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_WRIST_TWIST_META, 12) \ + _(XR_FULL_BODY_JOINT_RIGHT_SHOULDER_META, 13) \ + _(XR_FULL_BODY_JOINT_RIGHT_SCAPULA_META, 14) \ + _(XR_FULL_BODY_JOINT_RIGHT_ARM_UPPER_META, 15) \ + _(XR_FULL_BODY_JOINT_RIGHT_ARM_LOWER_META, 16) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_WRIST_TWIST_META, 17) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_PALM_META, 18) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_WRIST_META, 19) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_METACARPAL_META, 20) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_PROXIMAL_META, 21) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_DISTAL_META, 22) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_TIP_META, 23) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_METACARPAL_META, 24) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_PROXIMAL_META, 25) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_INTERMEDIATE_META, 26) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_DISTAL_META, 27) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_TIP_META, 28) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_METACARPAL_META, 29) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_PROXIMAL_META, 30) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_INTERMEDIATE_META, 31) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_DISTAL_META, 32) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_TIP_META, 33) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_RING_METACARPAL_META, 34) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_RING_PROXIMAL_META, 35) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_RING_INTERMEDIATE_META, 36) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_RING_DISTAL_META, 37) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_RING_TIP_META, 38) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_METACARPAL_META, 39) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_PROXIMAL_META, 40) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_INTERMEDIATE_META, 41) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_DISTAL_META, 42) \ + _(XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_TIP_META, 43) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_PALM_META, 44) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_WRIST_META, 45) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_METACARPAL_META, 46) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_PROXIMAL_META, 47) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_DISTAL_META, 48) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_TIP_META, 49) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_METACARPAL_META, 50) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_PROXIMAL_META, 51) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_INTERMEDIATE_META, 52) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_DISTAL_META, 53) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_TIP_META, 54) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_METACARPAL_META, 55) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_PROXIMAL_META, 56) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_INTERMEDIATE_META, 57) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_DISTAL_META, 58) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_TIP_META, 59) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_RING_METACARPAL_META, 60) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_RING_PROXIMAL_META, 61) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_RING_INTERMEDIATE_META, 62) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_RING_DISTAL_META, 63) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_RING_TIP_META, 64) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_METACARPAL_META, 65) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_PROXIMAL_META, 66) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_INTERMEDIATE_META, 67) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_DISTAL_META, 68) \ + _(XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_TIP_META, 69) \ + _(XR_FULL_BODY_JOINT_LEFT_UPPER_LEG_META, 70) \ + _(XR_FULL_BODY_JOINT_LEFT_LOWER_LEG_META, 71) \ + _(XR_FULL_BODY_JOINT_LEFT_FOOT_ANKLE_TWIST_META, 72) \ + _(XR_FULL_BODY_JOINT_LEFT_FOOT_ANKLE_META, 73) \ + _(XR_FULL_BODY_JOINT_LEFT_FOOT_SUBTALAR_META, 74) \ + _(XR_FULL_BODY_JOINT_LEFT_FOOT_TRANSVERSE_META, 75) \ + _(XR_FULL_BODY_JOINT_LEFT_FOOT_BALL_META, 76) \ + _(XR_FULL_BODY_JOINT_RIGHT_UPPER_LEG_META, 77) \ + _(XR_FULL_BODY_JOINT_RIGHT_LOWER_LEG_META, 78) \ + _(XR_FULL_BODY_JOINT_RIGHT_FOOT_ANKLE_TWIST_META, 79) \ + _(XR_FULL_BODY_JOINT_RIGHT_FOOT_ANKLE_META, 80) \ + _(XR_FULL_BODY_JOINT_RIGHT_FOOT_SUBTALAR_META, 81) \ + _(XR_FULL_BODY_JOINT_RIGHT_FOOT_TRANSVERSE_META, 82) \ + _(XR_FULL_BODY_JOINT_RIGHT_FOOT_BALL_META, 83) \ + _(XR_FULL_BODY_JOINT_COUNT_META, 84) \ + _(XR_FULL_BODY_JOINT_NONE_META, 85) \ + _(XR_FULL_BODY_JOINT_MAX_ENUM_META, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrBodyTrackingCalibrationStateMETA(_) \ + _(XR_BODY_TRACKING_CALIBRATION_STATE_VALID_META, 1) \ + _(XR_BODY_TRACKING_CALIBRATION_STATE_CALIBRATING_META, 2) \ + _(XR_BODY_TRACKING_CALIBRATION_STATE_INVALID_META, 3) \ + _(XR_BODY_TRACKING_CALIBRATION_STATE_MAX_ENUM_META, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrBodyTrackingFidelityMETA(_) \ + _(XR_BODY_TRACKING_FIDELITY_LOW_META, 1) \ + _(XR_BODY_TRACKING_FIDELITY_HIGH_META, 2) \ + _(XR_BODY_TRACKING_FIDELITY_MAX_ENUM_META, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrFaceExpression2FB(_) \ + _(XR_FACE_EXPRESSION2_BROW_LOWERER_L_FB, 0) \ + _(XR_FACE_EXPRESSION2_BROW_LOWERER_R_FB, 1) \ + _(XR_FACE_EXPRESSION2_CHEEK_PUFF_L_FB, 2) \ + _(XR_FACE_EXPRESSION2_CHEEK_PUFF_R_FB, 3) \ + _(XR_FACE_EXPRESSION2_CHEEK_RAISER_L_FB, 4) \ + _(XR_FACE_EXPRESSION2_CHEEK_RAISER_R_FB, 5) \ + _(XR_FACE_EXPRESSION2_CHEEK_SUCK_L_FB, 6) \ + _(XR_FACE_EXPRESSION2_CHEEK_SUCK_R_FB, 7) \ + _(XR_FACE_EXPRESSION2_CHIN_RAISER_B_FB, 8) \ + _(XR_FACE_EXPRESSION2_CHIN_RAISER_T_FB, 9) \ + _(XR_FACE_EXPRESSION2_DIMPLER_L_FB, 10) \ + _(XR_FACE_EXPRESSION2_DIMPLER_R_FB, 11) \ + _(XR_FACE_EXPRESSION2_EYES_CLOSED_L_FB, 12) \ + _(XR_FACE_EXPRESSION2_EYES_CLOSED_R_FB, 13) \ + _(XR_FACE_EXPRESSION2_EYES_LOOK_DOWN_L_FB, 14) \ + _(XR_FACE_EXPRESSION2_EYES_LOOK_DOWN_R_FB, 15) \ + _(XR_FACE_EXPRESSION2_EYES_LOOK_LEFT_L_FB, 16) \ + _(XR_FACE_EXPRESSION2_EYES_LOOK_LEFT_R_FB, 17) \ + _(XR_FACE_EXPRESSION2_EYES_LOOK_RIGHT_L_FB, 18) \ + _(XR_FACE_EXPRESSION2_EYES_LOOK_RIGHT_R_FB, 19) \ + _(XR_FACE_EXPRESSION2_EYES_LOOK_UP_L_FB, 20) \ + _(XR_FACE_EXPRESSION2_EYES_LOOK_UP_R_FB, 21) \ + _(XR_FACE_EXPRESSION2_INNER_BROW_RAISER_L_FB, 22) \ + _(XR_FACE_EXPRESSION2_INNER_BROW_RAISER_R_FB, 23) \ + _(XR_FACE_EXPRESSION2_JAW_DROP_FB, 24) \ + _(XR_FACE_EXPRESSION2_JAW_SIDEWAYS_LEFT_FB, 25) \ + _(XR_FACE_EXPRESSION2_JAW_SIDEWAYS_RIGHT_FB, 26) \ + _(XR_FACE_EXPRESSION2_JAW_THRUST_FB, 27) \ + _(XR_FACE_EXPRESSION2_LID_TIGHTENER_L_FB, 28) \ + _(XR_FACE_EXPRESSION2_LID_TIGHTENER_R_FB, 29) \ + _(XR_FACE_EXPRESSION2_LIP_CORNER_DEPRESSOR_L_FB, 30) \ + _(XR_FACE_EXPRESSION2_LIP_CORNER_DEPRESSOR_R_FB, 31) \ + _(XR_FACE_EXPRESSION2_LIP_CORNER_PULLER_L_FB, 32) \ + _(XR_FACE_EXPRESSION2_LIP_CORNER_PULLER_R_FB, 33) \ + _(XR_FACE_EXPRESSION2_LIP_FUNNELER_LB_FB, 34) \ + _(XR_FACE_EXPRESSION2_LIP_FUNNELER_LT_FB, 35) \ + _(XR_FACE_EXPRESSION2_LIP_FUNNELER_RB_FB, 36) \ + _(XR_FACE_EXPRESSION2_LIP_FUNNELER_RT_FB, 37) \ + _(XR_FACE_EXPRESSION2_LIP_PRESSOR_L_FB, 38) \ + _(XR_FACE_EXPRESSION2_LIP_PRESSOR_R_FB, 39) \ + _(XR_FACE_EXPRESSION2_LIP_PUCKER_L_FB, 40) \ + _(XR_FACE_EXPRESSION2_LIP_PUCKER_R_FB, 41) \ + _(XR_FACE_EXPRESSION2_LIP_STRETCHER_L_FB, 42) \ + _(XR_FACE_EXPRESSION2_LIP_STRETCHER_R_FB, 43) \ + _(XR_FACE_EXPRESSION2_LIP_SUCK_LB_FB, 44) \ + _(XR_FACE_EXPRESSION2_LIP_SUCK_LT_FB, 45) \ + _(XR_FACE_EXPRESSION2_LIP_SUCK_RB_FB, 46) \ + _(XR_FACE_EXPRESSION2_LIP_SUCK_RT_FB, 47) \ + _(XR_FACE_EXPRESSION2_LIP_TIGHTENER_L_FB, 48) \ + _(XR_FACE_EXPRESSION2_LIP_TIGHTENER_R_FB, 49) \ + _(XR_FACE_EXPRESSION2_LIPS_TOWARD_FB, 50) \ + _(XR_FACE_EXPRESSION2_LOWER_LIP_DEPRESSOR_L_FB, 51) \ + _(XR_FACE_EXPRESSION2_LOWER_LIP_DEPRESSOR_R_FB, 52) \ + _(XR_FACE_EXPRESSION2_MOUTH_LEFT_FB, 53) \ + _(XR_FACE_EXPRESSION2_MOUTH_RIGHT_FB, 54) \ + _(XR_FACE_EXPRESSION2_NOSE_WRINKLER_L_FB, 55) \ + _(XR_FACE_EXPRESSION2_NOSE_WRINKLER_R_FB, 56) \ + _(XR_FACE_EXPRESSION2_OUTER_BROW_RAISER_L_FB, 57) \ + _(XR_FACE_EXPRESSION2_OUTER_BROW_RAISER_R_FB, 58) \ + _(XR_FACE_EXPRESSION2_UPPER_LID_RAISER_L_FB, 59) \ + _(XR_FACE_EXPRESSION2_UPPER_LID_RAISER_R_FB, 60) \ + _(XR_FACE_EXPRESSION2_UPPER_LIP_RAISER_L_FB, 61) \ + _(XR_FACE_EXPRESSION2_UPPER_LIP_RAISER_R_FB, 62) \ + _(XR_FACE_EXPRESSION2_TONGUE_TIP_INTERDENTAL_FB, 63) \ + _(XR_FACE_EXPRESSION2_TONGUE_TIP_ALVEOLAR_FB, 64) \ + _(XR_FACE_EXPRESSION2_TONGUE_FRONT_DORSAL_PALATE_FB, 65) \ + _(XR_FACE_EXPRESSION2_TONGUE_MID_DORSAL_PALATE_FB, 66) \ + _(XR_FACE_EXPRESSION2_TONGUE_BACK_DORSAL_VELAR_FB, 67) \ + _(XR_FACE_EXPRESSION2_TONGUE_OUT_FB, 68) \ + _(XR_FACE_EXPRESSION2_TONGUE_RETREAT_FB, 69) \ + _(XR_FACE_EXPRESSION2_COUNT_FB, 70) \ + _(XR_FACE_EXPRESSION_2FB_MAX_ENUM_FB, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrFaceExpressionSet2FB(_) \ + _(XR_FACE_EXPRESSION_SET2_DEFAULT_FB, 0) \ + _(XR_FACE_EXPRESSION_SET_2FB_MAX_ENUM_FB, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrFaceTrackingDataSource2FB(_) \ + _(XR_FACE_TRACKING_DATA_SOURCE2_VISUAL_FB, 0) \ + _(XR_FACE_TRACKING_DATA_SOURCE2_AUDIO_FB, 1) \ + _(XR_FACE_TRACKING_DATA_SOURCE_2FB_MAX_ENUM_FB, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrFaceConfidence2FB(_) \ + _(XR_FACE_CONFIDENCE2_LOWER_FACE_FB, 0) \ + _(XR_FACE_CONFIDENCE2_UPPER_FACE_FB, 1) \ + _(XR_FACE_CONFIDENCE2_COUNT_FB, 2) \ + _(XR_FACE_CONFIDENCE_2FB_MAX_ENUM_FB, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrTrackingOptimizationSettingsDomainQCOM(_) \ + _(XR_TRACKING_OPTIMIZATION_SETTINGS_DOMAIN_ALL_QCOM, 1) \ + _(XR_TRACKING_OPTIMIZATION_SETTINGS_DOMAIN_MAX_ENUM_QCOM, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrTrackingOptimizationSettingsHintQCOM(_) \ + _(XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_NONE_QCOM, 0) \ + _(XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LONG_RANGE_PRIORITIZATION_QCOM, 1) \ + _(XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_CLOSE_RANGE_PRIORITIZATION_QCOM, 2) \ + _(XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LOW_POWER_PRIORITIZATION_QCOM, 3) \ + _(XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_HIGH_POWER_PRIORITIZATION_QCOM, 4) \ + _(XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_MAX_ENUM_QCOM, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrHandGestureTypeQCOM(_) \ + _(XR_HAND_GESTURE_TYPE_UNKNOWN_QCOM, -1) \ + _(XR_HAND_GESTURE_TYPE_OPEN_HAND_QCOM, 0) \ + _(XR_HAND_GESTURE_TYPE_GRAB_QCOM, 2) \ + _(XR_HAND_GESTURE_TYPE_PINCH_QCOM, 7) \ + _(XR_HAND_GESTURE_TYPE_MAX_ENUM_QCOM, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrPassthroughFormHTC(_) \ + _(XR_PASSTHROUGH_FORM_PLANAR_HTC, 0) \ + _(XR_PASSTHROUGH_FORM_PROJECTED_HTC, 1) \ + _(XR_PASSTHROUGH_FORM_MAX_ENUM_HTC, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrFoveationModeHTC(_) \ + _(XR_FOVEATION_MODE_DISABLE_HTC, 0) \ + _(XR_FOVEATION_MODE_FIXED_HTC, 1) \ + _(XR_FOVEATION_MODE_DYNAMIC_HTC, 2) \ + _(XR_FOVEATION_MODE_CUSTOM_HTC, 3) \ + _(XR_FOVEATION_MODE_MAX_ENUM_HTC, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrFoveationLevelHTC(_) \ + _(XR_FOVEATION_LEVEL_NONE_HTC, 0) \ + _(XR_FOVEATION_LEVEL_LOW_HTC, 1) \ + _(XR_FOVEATION_LEVEL_MEDIUM_HTC, 2) \ + _(XR_FOVEATION_LEVEL_HIGH_HTC, 3) \ + _(XR_FOVEATION_LEVEL_MAX_ENUM_HTC, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrBodyJointHTC(_) \ + _(XR_BODY_JOINT_PELVIS_HTC, 0) \ + _(XR_BODY_JOINT_LEFT_HIP_HTC, 1) \ + _(XR_BODY_JOINT_LEFT_KNEE_HTC, 2) \ + _(XR_BODY_JOINT_LEFT_ANKLE_HTC, 3) \ + _(XR_BODY_JOINT_LEFT_FEET_HTC, 4) \ + _(XR_BODY_JOINT_RIGHT_HIP_HTC, 5) \ + _(XR_BODY_JOINT_RIGHT_KNEE_HTC, 6) \ + _(XR_BODY_JOINT_RIGHT_ANKLE_HTC, 7) \ + _(XR_BODY_JOINT_RIGHT_FEET_HTC, 8) \ + _(XR_BODY_JOINT_WAIST_HTC, 9) \ + _(XR_BODY_JOINT_SPINE_LOWER_HTC, 10) \ + _(XR_BODY_JOINT_SPINE_MIDDLE_HTC, 11) \ + _(XR_BODY_JOINT_SPINE_HIGH_HTC, 12) \ + _(XR_BODY_JOINT_CHEST_HTC, 13) \ + _(XR_BODY_JOINT_NECK_HTC, 14) \ + _(XR_BODY_JOINT_HEAD_HTC, 15) \ + _(XR_BODY_JOINT_LEFT_CLAVICLE_HTC, 16) \ + _(XR_BODY_JOINT_LEFT_SCAPULA_HTC, 17) \ + _(XR_BODY_JOINT_LEFT_ARM_HTC, 18) \ + _(XR_BODY_JOINT_LEFT_ELBOW_HTC, 19) \ + _(XR_BODY_JOINT_LEFT_WRIST_HTC, 20) \ + _(XR_BODY_JOINT_RIGHT_CLAVICLE_HTC, 21) \ + _(XR_BODY_JOINT_RIGHT_SCAPULA_HTC, 22) \ + _(XR_BODY_JOINT_RIGHT_ARM_HTC, 23) \ + _(XR_BODY_JOINT_RIGHT_ELBOW_HTC, 24) \ + _(XR_BODY_JOINT_RIGHT_WRIST_HTC, 25) \ + _(XR_BODY_JOINT_MAX_ENUM_HTC, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrBodyJointSetHTC(_) \ + _(XR_BODY_JOINT_SET_FULL_HTC, 0) \ + _(XR_BODY_JOINT_SET_MAX_ENUM_HTC, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrBodyJointConfidenceHTC(_) \ + _(XR_BODY_JOINT_CONFIDENCE_NONE_HTC, 0) \ + _(XR_BODY_JOINT_CONFIDENCE_LOW_HTC, 1) \ + _(XR_BODY_JOINT_CONFIDENCE_HIGH_HTC, 2) \ + _(XR_BODY_JOINT_CONFIDENCE_MAX_ENUM_HTC, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrForceFeedbackCurlLocationMNDX(_) \ + _(XR_FORCE_FEEDBACK_CURL_LOCATION_THUMB_CURL_MNDX, 0) \ + _(XR_FORCE_FEEDBACK_CURL_LOCATION_INDEX_CURL_MNDX, 1) \ + _(XR_FORCE_FEEDBACK_CURL_LOCATION_MIDDLE_CURL_MNDX, 2) \ + _(XR_FORCE_FEEDBACK_CURL_LOCATION_RING_CURL_MNDX, 3) \ + _(XR_FORCE_FEEDBACK_CURL_LOCATION_LITTLE_CURL_MNDX, 4) \ + _(XR_FORCE_FEEDBACK_CURL_LOCATION_MAX_ENUM_MNDX, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrBodyJointBD(_) \ + _(XR_BODY_JOINT_PELVIS_BD, 0) \ + _(XR_BODY_JOINT_LEFT_HIP_BD, 1) \ + _(XR_BODY_JOINT_RIGHT_HIP_BD, 2) \ + _(XR_BODY_JOINT_SPINE1_BD, 3) \ + _(XR_BODY_JOINT_LEFT_KNEE_BD, 4) \ + _(XR_BODY_JOINT_RIGHT_KNEE_BD, 5) \ + _(XR_BODY_JOINT_SPINE2_BD, 6) \ + _(XR_BODY_JOINT_LEFT_ANKLE_BD, 7) \ + _(XR_BODY_JOINT_RIGHT_ANKLE_BD, 8) \ + _(XR_BODY_JOINT_SPINE3_BD, 9) \ + _(XR_BODY_JOINT_LEFT_FOOT_BD, 10) \ + _(XR_BODY_JOINT_RIGHT_FOOT_BD, 11) \ + _(XR_BODY_JOINT_NECK_BD, 12) \ + _(XR_BODY_JOINT_LEFT_COLLAR_BD, 13) \ + _(XR_BODY_JOINT_RIGHT_COLLAR_BD, 14) \ + _(XR_BODY_JOINT_HEAD_BD, 15) \ + _(XR_BODY_JOINT_LEFT_SHOULDER_BD, 16) \ + _(XR_BODY_JOINT_RIGHT_SHOULDER_BD, 17) \ + _(XR_BODY_JOINT_LEFT_ELBOW_BD, 18) \ + _(XR_BODY_JOINT_RIGHT_ELBOW_BD, 19) \ + _(XR_BODY_JOINT_LEFT_WRIST_BD, 20) \ + _(XR_BODY_JOINT_RIGHT_WRIST_BD, 21) \ + _(XR_BODY_JOINT_LEFT_HAND_BD, 22) \ + _(XR_BODY_JOINT_RIGHT_HAND_BD, 23) \ + _(XR_BODY_JOINT_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrBodyJointSetBD(_) \ + _(XR_BODY_JOINT_SET_BODY_WITHOUT_ARM_BD, 1) \ + _(XR_BODY_JOINT_SET_FULL_BODY_JOINTS_BD, 2) \ + _(XR_BODY_JOINT_SET_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrFacialSimulationModeBD(_) \ + _(XR_FACIAL_SIMULATION_MODE_DEFAULT_BD, 0) \ + _(XR_FACIAL_SIMULATION_MODE_COMBINED_AUDIO_BD, 1) \ + _(XR_FACIAL_SIMULATION_MODE_COMBINED_AUDIO_WITH_LIP_BD, 2) \ + _(XR_FACIAL_SIMULATION_MODE_ONLY_AUDIO_WITH_LIP_BD, 3) \ + _(XR_FACIAL_SIMULATION_MODE_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrFaceExpressionBD(_) \ + _(XR_FACE_EXPRESSION_BROW_DROP_L_BD, 0) \ + _(XR_FACE_EXPRESSION_BROW_DROP_R_BD, 1) \ + _(XR_FACE_EXPRESSION_BROW_INNER_UPWARDS_BD, 2) \ + _(XR_FACE_EXPRESSION_BROW_OUTER_UPWARDS_L_BD, 3) \ + _(XR_FACE_EXPRESSION_BROW_OUTER_UPWARDS_R_BD, 4) \ + _(XR_FACE_EXPRESSION_EYE_BLINK_L_BD, 5) \ + _(XR_FACE_EXPRESSION_EYE_LOOK_DROP_L_BD, 6) \ + _(XR_FACE_EXPRESSION_EYE_LOOK_IN_L_BD, 7) \ + _(XR_FACE_EXPRESSION_EYE_LOOK_OUT_L_BD, 8) \ + _(XR_FACE_EXPRESSION_EYE_LOOK_UPWARDS_L_BD, 9) \ + _(XR_FACE_EXPRESSION_EYE_LOOK_SQUINT_L_BD, 10) \ + _(XR_FACE_EXPRESSION_EYE_LOOK_WIDE_L_BD, 11) \ + _(XR_FACE_EXPRESSION_EYE_BLINK_R_BD, 12) \ + _(XR_FACE_EXPRESSION_EYE_LOOK_DROP_R_BD, 13) \ + _(XR_FACE_EXPRESSION_EYE_LOOK_IN_R_BD, 14) \ + _(XR_FACE_EXPRESSION_EYE_LOOK_OUT_R_BD, 15) \ + _(XR_FACE_EXPRESSION_EYE_LOOK_UPWARDS_R_BD, 16) \ + _(XR_FACE_EXPRESSION_EYE_LOOK_SQUINT_R_BD, 17) \ + _(XR_FACE_EXPRESSION_EYE_LOOK_WIDE_R_BD, 18) \ + _(XR_FACE_EXPRESSION_NOSE_SNEER_L_BD, 19) \ + _(XR_FACE_EXPRESSION_NOSE_SNEER_R_BD, 20) \ + _(XR_FACE_EXPRESSION_CHEEK_PUFF_BD, 21) \ + _(XR_FACE_EXPRESSION_CHEEK_SQUINT_L_BD, 22) \ + _(XR_FACE_EXPRESSION_CHEEK_SQUINT_R_BD, 23) \ + _(XR_FACE_EXPRESSION_MOUTH_CLOSE_BD, 24) \ + _(XR_FACE_EXPRESSION_MOUTH_FUNNEL_BD, 25) \ + _(XR_FACE_EXPRESSION_MOUTH_PUCKER_BD, 26) \ + _(XR_FACE_EXPRESSION_MOUTH_L_BD, 27) \ + _(XR_FACE_EXPRESSION_MOUTH_R_BD, 28) \ + _(XR_FACE_EXPRESSION_MOUTH_SMILE_L_BD, 29) \ + _(XR_FACE_EXPRESSION_MOUTH_SMILE_R_BD, 30) \ + _(XR_FACE_EXPRESSION_MOUTH_FROWN_L_BD, 31) \ + _(XR_FACE_EXPRESSION_MOUTH_FROWN_R_BD, 32) \ + _(XR_FACE_EXPRESSION_MOUTH_DIMPLE_L_BD, 33) \ + _(XR_FACE_EXPRESSION_MOUTH_DIMPLE_R_BD, 34) \ + _(XR_FACE_EXPRESSION_MOUTH_STRETCH_L_BD, 35) \ + _(XR_FACE_EXPRESSION_MOUTH_STRETCH_R_BD, 36) \ + _(XR_FACE_EXPRESSION_MOUTH_ROLL_LOWER_BD, 37) \ + _(XR_FACE_EXPRESSION_MOUTH_ROLL_UPPER_BD, 38) \ + _(XR_FACE_EXPRESSION_MOUTH_SHRUG_LOWER_BD, 39) \ + _(XR_FACE_EXPRESSION_MOUTH_SHRUG_UPPER_BD, 40) \ + _(XR_FACE_EXPRESSION_MOUTH_PRESS_L_BD, 41) \ + _(XR_FACE_EXPRESSION_MOUTH_PRESS_R_BD, 42) \ + _(XR_FACE_EXPRESSION_MOUTH_LOWER_DROP_L_BD, 43) \ + _(XR_FACE_EXPRESSION_MOUTH_LOWER_DROP_R_BD, 44) \ + _(XR_FACE_EXPRESSION_MOUTH_UPPER_UPWARDS_L_BD, 45) \ + _(XR_FACE_EXPRESSION_MOUTH_UPPER_UPWARDS_R_BD, 46) \ + _(XR_FACE_EXPRESSION_JAW_FORWARD_BD, 47) \ + _(XR_FACE_EXPRESSION_JAW_L_BD, 48) \ + _(XR_FACE_EXPRESSION_JAW_R_BD, 49) \ + _(XR_FACE_EXPRESSION_JAW_OPEN_BD, 50) \ + _(XR_FACE_EXPRESSION_TONGUE_OUT_BD, 51) \ + _(XR_FACE_EXPRESSION_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrLipExpressionBD(_) \ + _(XR_LIP_EXPRESSION_PP_BD, 0) \ + _(XR_LIP_EXPRESSION_CH_BD, 1) \ + _(XR_LIP_EXPRESSION_LO_BD, 2) \ + _(XR_LIP_EXPRESSION_O_BD, 3) \ + _(XR_LIP_EXPRESSION_I_BD, 4) \ + _(XR_LIP_EXPRESSION_LU_BD, 5) \ + _(XR_LIP_EXPRESSION_RR_BD, 6) \ + _(XR_LIP_EXPRESSION_XX_BD, 7) \ + _(XR_LIP_EXPRESSION_LAA_BD, 8) \ + _(XR_LIP_EXPRESSION_LI_BD, 9) \ + _(XR_LIP_EXPRESSION_FF_BD, 10) \ + _(XR_LIP_EXPRESSION_U_BD, 11) \ + _(XR_LIP_EXPRESSION_TH_BD, 12) \ + _(XR_LIP_EXPRESSION_LKK_BD, 13) \ + _(XR_LIP_EXPRESSION_SS_BD, 14) \ + _(XR_LIP_EXPRESSION_LE_BD, 15) \ + _(XR_LIP_EXPRESSION_DD_BD, 16) \ + _(XR_LIP_EXPRESSION_E_BD, 17) \ + _(XR_LIP_EXPRESSION_LNN_BD, 18) \ + _(XR_LIP_EXPRESSION_SIL_BD, 19) \ + _(XR_LIP_EXPRESSION_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpatialEntityComponentTypeBD(_) \ + _(XR_SPATIAL_ENTITY_COMPONENT_TYPE_LOCATION_BD, 0) \ + _(XR_SPATIAL_ENTITY_COMPONENT_TYPE_SEMANTIC_BD, 1) \ + _(XR_SPATIAL_ENTITY_COMPONENT_TYPE_BOUNDING_BOX_2D_BD, 2) \ + _(XR_SPATIAL_ENTITY_COMPONENT_TYPE_POLYGON_BD, 3) \ + _(XR_SPATIAL_ENTITY_COMPONENT_TYPE_BOUNDING_BOX_3D_BD, 4) \ + _(XR_SPATIAL_ENTITY_COMPONENT_TYPE_TRIANGLE_MESH_BD, 5) \ + _(XR_SPATIAL_ENTITY_COMPONENT_TYPE_SPHERE_BD, 6) \ + _(XR_SPATIAL_ENTITY_COMPONENT_TYPE_PLANE_ORIENTATION_BD, 1000396000) \ + _(XR_SPATIAL_ENTITY_COMPONENT_TYPE_LIGHT_ESTIMATION_BD, 1000397000) \ + _(XR_SPATIAL_ENTITY_COMPONENT_TYPE_DYNAMIC_OBJECT_BD, 1000746000) \ + _(XR_SPATIAL_ENTITY_COMPONENT_TYPE_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSemanticLabelBD(_) \ + _(XR_SEMANTIC_LABEL_UNKNOWN_BD, 0) \ + _(XR_SEMANTIC_LABEL_FLOOR_BD, 1) \ + _(XR_SEMANTIC_LABEL_CEILING_BD, 2) \ + _(XR_SEMANTIC_LABEL_WALL_BD, 3) \ + _(XR_SEMANTIC_LABEL_DOOR_BD, 4) \ + _(XR_SEMANTIC_LABEL_WINDOW_BD, 5) \ + _(XR_SEMANTIC_LABEL_OPENING_BD, 6) \ + _(XR_SEMANTIC_LABEL_TABLE_BD, 7) \ + _(XR_SEMANTIC_LABEL_SOFA_BD, 8) \ + _(XR_SEMANTIC_LABEL_CHAIR_BD, 9) \ + _(XR_SEMANTIC_LABEL_HUMAN_BD, 10) \ + _(XR_SEMANTIC_LABEL_BEAM_BD, 11) \ + _(XR_SEMANTIC_LABEL_COLUMN_BD, 12) \ + _(XR_SEMANTIC_LABEL_CURTAIN_BD, 13) \ + _(XR_SEMANTIC_LABEL_CABINET_BD, 14) \ + _(XR_SEMANTIC_LABEL_BED_BD, 15) \ + _(XR_SEMANTIC_LABEL_PLANT_BD, 16) \ + _(XR_SEMANTIC_LABEL_SCREEN_BD, 17) \ + _(XR_SEMANTIC_LABEL_VIRTUAL_WALL_BD, 18) \ + _(XR_SEMANTIC_LABEL_REFRIGERATOR_BD, 19) \ + _(XR_SEMANTIC_LABEL_WASHING_MACHINE_BD, 20) \ + _(XR_SEMANTIC_LABEL_AIR_CONDITIONER_BD, 21) \ + _(XR_SEMANTIC_LABEL_LAMP_BD, 22) \ + _(XR_SEMANTIC_LABEL_WALL_ART_BD, 23) \ + _(XR_SEMANTIC_LABEL_STAIRWAY_BD, 24) \ + _(XR_SEMANTIC_LABEL_KEYBOARD_BD, 25) \ + _(XR_SEMANTIC_LABEL_MOUSE_BD, 26) \ + _(XR_SEMANTIC_LABEL_LAPTOP_BD, 27) \ + _(XR_SEMANTIC_LABEL_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSenseDataProviderTypeBD(_) \ + _(XR_SENSE_DATA_PROVIDER_TYPE_ANCHOR_BD, 1000390000) \ + _(XR_SENSE_DATA_PROVIDER_TYPE_SCENE_BD, 1000392000) \ + _(XR_SENSE_DATA_PROVIDER_TYPE_MESH_BD, 1000393000) \ + _(XR_SENSE_DATA_PROVIDER_TYPE_PLANE_BD, 1000396000) \ + _(XR_SENSE_DATA_PROVIDER_TYPE_LIGHT_ESTIMATION_BD, 1000397000) \ + _(XR_SENSE_DATA_PROVIDER_TYPE_DYNAMIC_OBJECT_BD, 1000746000) \ + _(XR_SENSE_DATA_PROVIDER_TYPE_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSenseDataProviderStateBD(_) \ + _(XR_SENSE_DATA_PROVIDER_STATE_INITIALIZED_BD, 0) \ + _(XR_SENSE_DATA_PROVIDER_STATE_RUNNING_BD, 1) \ + _(XR_SENSE_DATA_PROVIDER_STATE_STOPPED_BD, 2) \ + _(XR_SENSE_DATA_PROVIDER_STATE_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrPersistenceLocationBD(_) \ + _(XR_PERSISTENCE_LOCATION_LOCAL_BD, 0) \ + _(XR_PERSISTENCE_LOCATION_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpatialMeshLodBD(_) \ + _(XR_SPATIAL_MESH_LOD_COARSE_BD, 0) \ + _(XR_SPATIAL_MESH_LOD_MEDIUM_BD, 1) \ + _(XR_SPATIAL_MESH_LOD_FINE_BD, 2) \ + _(XR_SPATIAL_MESH_LOD_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrBodyTrackingPostureBD(_) \ + _(XR_BODY_TRACKING_POSTURE_STOMP_BD, 1) \ + _(XR_BODY_TRACKING_POSTURE_STATIC_BD, 2) \ + _(XR_BODY_TRACKING_POSTURE_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrBodyTrackingStatusBD(_) \ + _(XR_BODY_TRACKING_STATUS_INVALID_BD, 0) \ + _(XR_BODY_TRACKING_STATUS_VALID_BD, 1) \ + _(XR_BODY_TRACKING_STATUS_LIMITED_BD, 2) \ + _(XR_BODY_TRACKING_STATUS_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrBodyTrackingMessageBD(_) \ + _(XR_BODY_TRACKING_MESSAGE_NO_ERROR_BD, 0) \ + _(XR_BODY_TRACKING_MESSAGE_TRACKER_NOT_CALIBRATED_BD, 1) \ + _(XR_BODY_TRACKING_MESSAGE_TRACKER_NUM_NOT_ENOUGH_BD, 2) \ + _(XR_BODY_TRACKING_MESSAGE_TRACKER_STATE_NOT_SATISFIED_BD, 3) \ + _(XR_BODY_TRACKING_MESSAGE_TRACKER_PERSISTENT_INVISIBILITY_BD, 4) \ + _(XR_BODY_TRACKING_MESSAGE_TRACKER_DATA_ERROR_BD, 5) \ + _(XR_BODY_TRACKING_MESSAGE_USER_CHANGE_BD, 6) \ + _(XR_BODY_TRACKING_MESSAGE_TRACKING_POSE_ERROR_BD, 7) \ + _(XR_BODY_TRACKING_MESSAGE_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrPlaneOrientationBD(_) \ + _(XR_PLANE_ORIENTATION_HORIZONTAL_UPWARD_BD, 0) \ + _(XR_PLANE_ORIENTATION_HORIZONTAL_DOWNWARD_BD, 1) \ + _(XR_PLANE_ORIENTATION_VERTICAL_BD, 2) \ + _(XR_PLANE_ORIENTATION_ARBITRARY_BD, 3) \ + _(XR_PLANE_ORIENTATION_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrEnvironmentTexturePixelFormatBD(_) \ + _(XR_ENVIRONMENT_TEXTURE_PIXEL_FORMAT_RGB_16FLOAT_BD, 0) \ + _(XR_ENVIRONMENT_TEXTURE_PIXEL_FORMAT_RGBA_16FLOAT_BD, 1) \ + _(XR_ENVIRONMENT_TEXTURE_PIXEL_FORMAT_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrEnvironmentTextureResolutionBD(_) \ + _(XR_ENVIRONMENT_TEXTURE_RESOLUTION_8_8_BD, 0) \ + _(XR_ENVIRONMENT_TEXTURE_RESOLUTION_16_16_BD, 1) \ + _(XR_ENVIRONMENT_TEXTURE_RESOLUTION_32_32_BD, 2) \ + _(XR_ENVIRONMENT_TEXTURE_RESOLUTION_64_64_BD, 3) \ + _(XR_ENVIRONMENT_TEXTURE_RESOLUTION_128_128_BD, 4) \ + _(XR_ENVIRONMENT_TEXTURE_RESOLUTION_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrEnvironmentTextureTransferTypeBD(_) \ + _(XR_ENVIRONMENT_TEXTURE_TRANSFER_TYPE_RAW_BD, 0) \ + _(XR_ENVIRONMENT_TEXTURE_TRANSFER_TYPE_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSphericalHarmonicsKindBD(_) \ + _(XR_SPHERICAL_HARMONICS_KIND_TOTAL_BD, 0) \ + _(XR_SPHERICAL_HARMONICS_KIND_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrAudioSampleRateBD(_) \ + _(XR_AUDIO_SAMPLE_RATE_192000_HZ_BD, 1) \ + _(XR_AUDIO_SAMPLE_RATE_96000_HZ_BD, 2) \ + _(XR_AUDIO_SAMPLE_RATE_48000_HZ_BD, 3) \ + _(XR_AUDIO_SAMPLE_RATE_44100_HZ_BD, 4) \ + _(XR_AUDIO_SAMPLE_RATE_32000_HZ_BD, 5) \ + _(XR_AUDIO_SAMPLE_RATE_24000_HZ_BD, 6) \ + _(XR_AUDIO_SAMPLE_RATE_22050_HZ_BD, 7) \ + _(XR_AUDIO_SAMPLE_RATE_16000_HZ_BD, 8) \ + _(XR_AUDIO_SAMPLE_RATE_12000_HZ_BD, 9) \ + _(XR_AUDIO_SAMPLE_RATE_11025_HZ_BD, 10) \ + _(XR_AUDIO_SAMPLE_RATE_8000_HZ_BD, 11) \ + _(XR_AUDIO_SAMPLE_RATE_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrAudioBufferChannelLayoutBD(_) \ + _(XR_AUDIO_BUFFER_CHANNEL_LAYOUT_INTERLEAVED_BD, 0) \ + _(XR_AUDIO_BUFFER_CHANNEL_LAYOUT_PLANAR_BD, 1) \ + _(XR_AUDIO_BUFFER_CHANNEL_LAYOUT_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSoundObjectDistanceAttenuationTypeBD(_) \ + _(XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_NONE_BD, 0) \ + _(XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_INVERSE_SQUARE_BD, 1) \ + _(XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_ROLLOFF_BD, 2) \ + _(XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_CUSTOMIZED_BD, 100) \ + _(XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSoundFieldChannelMaskSurroundBD(_) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_LEFT_BD, 1) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_RIGHT_BD, 2) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_CENTER_BD, 4) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_LOW_FREQUENCY_BD, 8) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_LEFT_BD, 16) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_RIGHT_BD, 32) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SIDE_LEFT_BD, 64) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SIDE_RIGHT_BD, 128) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_LEFT_BD, 256) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_RIGHT_BD, 512) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_BACK_LEFT_BD, 1024) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_BACK_RIGHT_BD, 2048) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_CENTER_BD, 4096) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_SIDE_LEFT_BD, 8192) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_SIDE_RIGHT_BD, 16384) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_STEREO_BD, 3) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_2_1_BD, 11) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_3_0_BD, 7) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_4_0_BD, 4099) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_BACK_SURROUND_BD, 48) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_QUAD_BD, 51) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_3_1_BD, 15) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_0_BD, 55) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_SIDE_SURROUND_BD, 192) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_0_SIDE_BD, 199) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_BD, 63) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_SIDE_BD, 207) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_0_BD, 247) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_1_BD, 255) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_2_BD, 831) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_4_BD, 3903) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_1_2_BD, 24831) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_1_4_BD, 4095) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSoundFieldChannelMaskAmbixBD(_) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_1ST_ORDER_BD, 1) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_2ND_ORDER_BD, 2) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_3RD_ORDER_BD, 3) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_4TH_ORDER_BD, 4) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_5TH_ORDER_BD, 5) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_6TH_ORDER_BD, 6) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_7TH_ORDER_BD, 7) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSoundFieldChannelMaskFumaBD(_) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_FUMA_1ST_ORDER_BD, 1) \ + _(XR_SOUND_FIELD_CHANNEL_MASK_FUMA_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSoundObstacleMaterialTypeBD(_) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_ACOUSTIC_TILE_BD, 0) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_BRICK_BD, 1) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_BRICK_PAINTED_BD, 2) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_CARPET_BD, 3) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_CARPET_HEAVY_BD, 4) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_CARPET_HEAVY_PADDED_BD, 5) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_CERAMIC_TILE_BD, 6) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_BD, 7) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_ROUGH_BD, 8) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_BLOCK_BD, 9) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_BLOCK_PAINTED_BD, 10) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_CURTAIN_BD, 11) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_FOLIAGE_BD, 12) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_GLASS_BD, 13) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_GLASS_HEAVY_BD, 14) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_GRASS_BD, 15) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_GRAVEL_BD, 16) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_GYPSUM_BOARD_BD, 17) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_PLASTER_ON_BRICK_BD, 18) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_PLASTER_ON_CONCRETE_BLOCK_BD, 19) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_SOIL_BD, 20) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_SOUND_PROOF_BD, 21) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_SNOW_BD, 22) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_STEEL_BD, 23) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_WATER_BD, 24) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_THIN_BD, 25) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_THICK_BD, 26) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_FLOOR_BD, 27) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_ON_CONCRETE_BD, 28) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_CUSTOM_BD, 29) \ + _(XR_SOUND_OBSTACLE_MATERIAL_TYPE_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrHandTrackingDataSourceEXT(_) \ + _(XR_HAND_TRACKING_DATA_SOURCE_UNOBSTRUCTED_EXT, 1) \ + _(XR_HAND_TRACKING_DATA_SOURCE_CONTROLLER_EXT, 2) \ + _(XR_HAND_TRACKING_DATA_SOURCE_UNOBSTRUCTED_WIDE_MOTION_META, 1000695000) \ + _(XR_HAND_TRACKING_DATA_SOURCE_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrPlaneDetectorOrientationEXT(_) \ + _(XR_PLANE_DETECTOR_ORIENTATION_HORIZONTAL_UPWARD_EXT, 0) \ + _(XR_PLANE_DETECTOR_ORIENTATION_HORIZONTAL_DOWNWARD_EXT, 1) \ + _(XR_PLANE_DETECTOR_ORIENTATION_VERTICAL_EXT, 2) \ + _(XR_PLANE_DETECTOR_ORIENTATION_ARBITRARY_EXT, 3) \ + _(XR_PLANE_DETECTOR_ORIENTATION_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrPlaneDetectorSemanticTypeEXT(_) \ + _(XR_PLANE_DETECTOR_SEMANTIC_TYPE_UNDEFINED_EXT, 0) \ + _(XR_PLANE_DETECTOR_SEMANTIC_TYPE_CEILING_EXT, 1) \ + _(XR_PLANE_DETECTOR_SEMANTIC_TYPE_FLOOR_EXT, 2) \ + _(XR_PLANE_DETECTOR_SEMANTIC_TYPE_WALL_EXT, 3) \ + _(XR_PLANE_DETECTOR_SEMANTIC_TYPE_PLATFORM_EXT, 4) \ + _(XR_PLANE_DETECTOR_SEMANTIC_TYPE_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrPlaneDetectionStateEXT(_) \ + _(XR_PLANE_DETECTION_STATE_NONE_EXT, 0) \ + _(XR_PLANE_DETECTION_STATE_PENDING_EXT, 1) \ + _(XR_PLANE_DETECTION_STATE_DONE_EXT, 2) \ + _(XR_PLANE_DETECTION_STATE_ERROR_EXT, 3) \ + _(XR_PLANE_DETECTION_STATE_FATAL_EXT, 4) \ + _(XR_PLANE_DETECTION_STATE_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrTrackingStateANDROID(_) \ + _(XR_TRACKING_STATE_PAUSED_ANDROID, 0) \ + _(XR_TRACKING_STATE_STOPPED_ANDROID, 1) \ + _(XR_TRACKING_STATE_TRACKING_ANDROID, 2) \ + _(XR_TRACKING_STATE_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrTrackableTypeANDROID(_) \ + _(XR_TRACKABLE_TYPE_NOT_VALID_ANDROID, 0) \ + _(XR_TRACKABLE_TYPE_PLANE_ANDROID, 1) \ + _(XR_TRACKABLE_TYPE_DEPTH_ANDROID, 1000463000) \ + _(XR_TRACKABLE_TYPE_OBJECT_ANDROID, 1000466000) \ + _(XR_TRACKABLE_TYPE_MARKER_ANDROID, 1000707000) \ + _(XR_TRACKABLE_TYPE_QR_CODE_ANDROID, 1000708000) \ + _(XR_TRACKABLE_TYPE_IMAGE_ANDROID, 1000709000) \ + _(XR_TRACKABLE_TYPE_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrPlaneTypeANDROID(_) \ + _(XR_PLANE_TYPE_HORIZONTAL_DOWNWARD_FACING_ANDROID, 0) \ + _(XR_PLANE_TYPE_HORIZONTAL_UPWARD_FACING_ANDROID, 1) \ + _(XR_PLANE_TYPE_VERTICAL_ANDROID, 2) \ + _(XR_PLANE_TYPE_ARBITRARY_ANDROID, 3) \ + _(XR_PLANE_TYPE_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrPlaneLabelANDROID(_) \ + _(XR_PLANE_LABEL_UNKNOWN_ANDROID, 0) \ + _(XR_PLANE_LABEL_WALL_ANDROID, 1) \ + _(XR_PLANE_LABEL_FLOOR_ANDROID, 2) \ + _(XR_PLANE_LABEL_CEILING_ANDROID, 3) \ + _(XR_PLANE_LABEL_TABLE_ANDROID, 4) \ + _(XR_PLANE_LABEL_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrEyeIndexANDROID(_) \ + _(XR_EYE_INDEX_LEFT_ANDROID, 0) \ + _(XR_EYE_INDEX_RIGHT_ANDROID, 1) \ + _(XR_EYE_INDEX_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrEyeStateANDROID(_) \ + _(XR_EYE_STATE_INVALID_ANDROID, 0) \ + _(XR_EYE_STATE_GAZING_ANDROID, 1) \ + _(XR_EYE_STATE_SHUT_ANDROID, 2) \ + _(XR_EYE_STATE_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrEyeTrackingModeANDROID(_) \ + _(XR_EYE_TRACKING_MODE_NOT_TRACKING_ANDROID, 0) \ + _(XR_EYE_TRACKING_MODE_RIGHT_ANDROID, 1) \ + _(XR_EYE_TRACKING_MODE_LEFT_ANDROID, 2) \ + _(XR_EYE_TRACKING_MODE_BOTH_ANDROID, 3) \ + _(XR_EYE_TRACKING_MODE_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrAnchorPersistStateANDROID(_) \ + _(XR_ANCHOR_PERSIST_STATE_PERSIST_NOT_REQUESTED_ANDROID, 0) \ + _(XR_ANCHOR_PERSIST_STATE_PERSIST_PENDING_ANDROID, 1) \ + _(XR_ANCHOR_PERSIST_STATE_PERSISTED_ANDROID, 2) \ + _(XR_ANCHOR_PERSIST_STATE_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrFaceParameterIndicesANDROID(_) \ + _(XR_FACE_PARAMETER_INDICES_BROW_LOWERER_L_ANDROID, 0) \ + _(XR_FACE_PARAMETER_INDICES_BROW_LOWERER_R_ANDROID, 1) \ + _(XR_FACE_PARAMETER_INDICES_CHEEK_PUFF_L_ANDROID, 2) \ + _(XR_FACE_PARAMETER_INDICES_CHEEK_PUFF_R_ANDROID, 3) \ + _(XR_FACE_PARAMETER_INDICES_CHEEK_RAISER_L_ANDROID, 4) \ + _(XR_FACE_PARAMETER_INDICES_CHEEK_RAISER_R_ANDROID, 5) \ + _(XR_FACE_PARAMETER_INDICES_CHEEK_SUCK_L_ANDROID, 6) \ + _(XR_FACE_PARAMETER_INDICES_CHEEK_SUCK_R_ANDROID, 7) \ + _(XR_FACE_PARAMETER_INDICES_CHIN_RAISER_B_ANDROID, 8) \ + _(XR_FACE_PARAMETER_INDICES_CHIN_RAISER_T_ANDROID, 9) \ + _(XR_FACE_PARAMETER_INDICES_DIMPLER_L_ANDROID, 10) \ + _(XR_FACE_PARAMETER_INDICES_DIMPLER_R_ANDROID, 11) \ + _(XR_FACE_PARAMETER_INDICES_EYES_CLOSED_L_ANDROID, 12) \ + _(XR_FACE_PARAMETER_INDICES_EYES_CLOSED_R_ANDROID, 13) \ + _(XR_FACE_PARAMETER_INDICES_EYES_LOOK_DOWN_L_ANDROID, 14) \ + _(XR_FACE_PARAMETER_INDICES_EYES_LOOK_DOWN_R_ANDROID, 15) \ + _(XR_FACE_PARAMETER_INDICES_EYES_LOOK_LEFT_L_ANDROID, 16) \ + _(XR_FACE_PARAMETER_INDICES_EYES_LOOK_LEFT_R_ANDROID, 17) \ + _(XR_FACE_PARAMETER_INDICES_EYES_LOOK_RIGHT_L_ANDROID, 18) \ + _(XR_FACE_PARAMETER_INDICES_EYES_LOOK_RIGHT_R_ANDROID, 19) \ + _(XR_FACE_PARAMETER_INDICES_EYES_LOOK_UP_L_ANDROID, 20) \ + _(XR_FACE_PARAMETER_INDICES_EYES_LOOK_UP_R_ANDROID, 21) \ + _(XR_FACE_PARAMETER_INDICES_INNER_BROW_RAISER_L_ANDROID, 22) \ + _(XR_FACE_PARAMETER_INDICES_INNER_BROW_RAISER_R_ANDROID, 23) \ + _(XR_FACE_PARAMETER_INDICES_JAW_DROP_ANDROID, 24) \ + _(XR_FACE_PARAMETER_INDICES_JAW_SIDEWAYS_LEFT_ANDROID, 25) \ + _(XR_FACE_PARAMETER_INDICES_JAW_SIDEWAYS_RIGHT_ANDROID, 26) \ + _(XR_FACE_PARAMETER_INDICES_JAW_THRUST_ANDROID, 27) \ + _(XR_FACE_PARAMETER_INDICES_LID_TIGHTENER_L_ANDROID, 28) \ + _(XR_FACE_PARAMETER_INDICES_LID_TIGHTENER_R_ANDROID, 29) \ + _(XR_FACE_PARAMETER_INDICES_LIP_CORNER_DEPRESSOR_L_ANDROID, 30) \ + _(XR_FACE_PARAMETER_INDICES_LIP_CORNER_DEPRESSOR_R_ANDROID, 31) \ + _(XR_FACE_PARAMETER_INDICES_LIP_CORNER_PULLER_L_ANDROID, 32) \ + _(XR_FACE_PARAMETER_INDICES_LIP_CORNER_PULLER_R_ANDROID, 33) \ + _(XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_LB_ANDROID, 34) \ + _(XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_LT_ANDROID, 35) \ + _(XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_RB_ANDROID, 36) \ + _(XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_RT_ANDROID, 37) \ + _(XR_FACE_PARAMETER_INDICES_LIP_PRESSOR_L_ANDROID, 38) \ + _(XR_FACE_PARAMETER_INDICES_LIP_PRESSOR_R_ANDROID, 39) \ + _(XR_FACE_PARAMETER_INDICES_LIP_PUCKER_L_ANDROID, 40) \ + _(XR_FACE_PARAMETER_INDICES_LIP_PUCKER_R_ANDROID, 41) \ + _(XR_FACE_PARAMETER_INDICES_LIP_STRETCHER_L_ANDROID, 42) \ + _(XR_FACE_PARAMETER_INDICES_LIP_STRETCHER_R_ANDROID, 43) \ + _(XR_FACE_PARAMETER_INDICES_LIP_SUCK_LB_ANDROID, 44) \ + _(XR_FACE_PARAMETER_INDICES_LIP_SUCK_LT_ANDROID, 45) \ + _(XR_FACE_PARAMETER_INDICES_LIP_SUCK_RB_ANDROID, 46) \ + _(XR_FACE_PARAMETER_INDICES_LIP_SUCK_RT_ANDROID, 47) \ + _(XR_FACE_PARAMETER_INDICES_LIP_TIGHTENER_L_ANDROID, 48) \ + _(XR_FACE_PARAMETER_INDICES_LIP_TIGHTENER_R_ANDROID, 49) \ + _(XR_FACE_PARAMETER_INDICES_LIPS_TOWARD_ANDROID, 50) \ + _(XR_FACE_PARAMETER_INDICES_LOWER_LIP_DEPRESSOR_L_ANDROID, 51) \ + _(XR_FACE_PARAMETER_INDICES_LOWER_LIP_DEPRESSOR_R_ANDROID, 52) \ + _(XR_FACE_PARAMETER_INDICES_MOUTH_LEFT_ANDROID, 53) \ + _(XR_FACE_PARAMETER_INDICES_MOUTH_RIGHT_ANDROID, 54) \ + _(XR_FACE_PARAMETER_INDICES_NOSE_WRINKLER_L_ANDROID, 55) \ + _(XR_FACE_PARAMETER_INDICES_NOSE_WRINKLER_R_ANDROID, 56) \ + _(XR_FACE_PARAMETER_INDICES_OUTER_BROW_RAISER_L_ANDROID, 57) \ + _(XR_FACE_PARAMETER_INDICES_OUTER_BROW_RAISER_R_ANDROID, 58) \ + _(XR_FACE_PARAMETER_INDICES_UPPER_LID_RAISER_L_ANDROID, 59) \ + _(XR_FACE_PARAMETER_INDICES_UPPER_LID_RAISER_R_ANDROID, 60) \ + _(XR_FACE_PARAMETER_INDICES_UPPER_LIP_RAISER_L_ANDROID, 61) \ + _(XR_FACE_PARAMETER_INDICES_UPPER_LIP_RAISER_R_ANDROID, 62) \ + _(XR_FACE_PARAMETER_INDICES_TONGUE_OUT_ANDROID, 63) \ + _(XR_FACE_PARAMETER_INDICES_TONGUE_LEFT_ANDROID, 64) \ + _(XR_FACE_PARAMETER_INDICES_TONGUE_RIGHT_ANDROID, 65) \ + _(XR_FACE_PARAMETER_INDICES_TONGUE_UP_ANDROID, 66) \ + _(XR_FACE_PARAMETER_INDICES_TONGUE_DOWN_ANDROID, 67) \ + _(XR_FACE_PARAMETER_INDICES_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrFaceTrackingStateANDROID(_) \ + _(XR_FACE_TRACKING_STATE_PAUSED_ANDROID, 0) \ + _(XR_FACE_TRACKING_STATE_STOPPED_ANDROID, 1) \ + _(XR_FACE_TRACKING_STATE_TRACKING_ANDROID, 2) \ + _(XR_FACE_TRACKING_STATE_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrFaceConfidenceRegionsANDROID(_) \ + _(XR_FACE_CONFIDENCE_REGIONS_LOWER_ANDROID, 0) \ + _(XR_FACE_CONFIDENCE_REGIONS_LEFT_UPPER_ANDROID, 1) \ + _(XR_FACE_CONFIDENCE_REGIONS_RIGHT_UPPER_ANDROID, 2) \ + _(XR_FACE_CONFIDENCE_REGIONS_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrPassthroughCameraStateANDROID(_) \ + _(XR_PASSTHROUGH_CAMERA_STATE_DISABLED_ANDROID, 0) \ + _(XR_PASSTHROUGH_CAMERA_STATE_INITIALIZING_ANDROID, 1) \ + _(XR_PASSTHROUGH_CAMERA_STATE_READY_ANDROID, 2) \ + _(XR_PASSTHROUGH_CAMERA_STATE_ERROR_ANDROID, 3) \ + _(XR_PASSTHROUGH_CAMERA_STATE_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrWindingOrderANDROID(_) \ + _(XR_WINDING_ORDER_UNKNOWN_ANDROID, 0) \ + _(XR_WINDING_ORDER_CW_ANDROID, 1) \ + _(XR_WINDING_ORDER_CCW_ANDROID, 2) \ + _(XR_WINDING_ORDER_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrPerformanceMetricsCounterUnitANDROID(_) \ + _(XR_PERFORMANCE_METRICS_COUNTER_UNIT_GENERIC_ANDROID, 0) \ + _(XR_PERFORMANCE_METRICS_COUNTER_UNIT_PERCENTAGE_ANDROID, 1) \ + _(XR_PERFORMANCE_METRICS_COUNTER_UNIT_MILLISECONDS_ANDROID, 2) \ + _(XR_PERFORMANCE_METRICS_COUNTER_UNIT_BYTES_ANDROID, 3) \ + _(XR_PERFORMANCE_METRICS_COUNTER_UNIT_HERTZ_ANDROID, 4) \ + _(XR_PERFORMANCE_METRICS_COUNTER_UNIT_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrObjectLabelANDROID(_) \ + _(XR_OBJECT_LABEL_UNKNOWN_ANDROID, 0) \ + _(XR_OBJECT_LABEL_KEYBOARD_ANDROID, 1) \ + _(XR_OBJECT_LABEL_MOUSE_ANDROID, 2) \ + _(XR_OBJECT_LABEL_LAPTOP_ANDROID, 3) \ + _(XR_OBJECT_LABEL_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrFutureStateEXT(_) \ + _(XR_FUTURE_STATE_PENDING_EXT, 1) \ + _(XR_FUTURE_STATE_READY_EXT, 2) \ + _(XR_FUTURE_STATE_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrHeadsetFitStatusML(_) \ + _(XR_HEADSET_FIT_STATUS_UNKNOWN_ML, 0) \ + _(XR_HEADSET_FIT_STATUS_NOT_WORN_ML, 1) \ + _(XR_HEADSET_FIT_STATUS_GOOD_FIT_ML, 2) \ + _(XR_HEADSET_FIT_STATUS_BAD_FIT_ML, 3) \ + _(XR_HEADSET_FIT_STATUS_MAX_ENUM_ML, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrEyeCalibrationStatusML(_) \ + _(XR_EYE_CALIBRATION_STATUS_UNKNOWN_ML, 0) \ + _(XR_EYE_CALIBRATION_STATUS_NONE_ML, 1) \ + _(XR_EYE_CALIBRATION_STATUS_COARSE_ML, 2) \ + _(XR_EYE_CALIBRATION_STATUS_FINE_ML, 3) \ + _(XR_EYE_CALIBRATION_STATUS_MAX_ENUM_ML, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrWorldMeshDetectorLodML(_) \ + _(XR_WORLD_MESH_DETECTOR_LOD_MINIMUM_ML, 0) \ + _(XR_WORLD_MESH_DETECTOR_LOD_MEDIUM_ML, 1) \ + _(XR_WORLD_MESH_DETECTOR_LOD_MAXIMUM_ML, 2) \ + _(XR_WORLD_MESH_DETECTOR_LOD_MAX_ENUM_ML, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrWorldMeshBlockStatusML(_) \ + _(XR_WORLD_MESH_BLOCK_STATUS_NEW_ML, 0) \ + _(XR_WORLD_MESH_BLOCK_STATUS_UPDATED_ML, 1) \ + _(XR_WORLD_MESH_BLOCK_STATUS_DELETED_ML, 2) \ + _(XR_WORLD_MESH_BLOCK_STATUS_UNCHANGED_ML, 3) \ + _(XR_WORLD_MESH_BLOCK_STATUS_MAX_ENUM_ML, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrWorldMeshBlockResultML(_) \ + _(XR_WORLD_MESH_BLOCK_RESULT_SUCCESS_ML, 0) \ + _(XR_WORLD_MESH_BLOCK_RESULT_FAILED_ML, 1) \ + _(XR_WORLD_MESH_BLOCK_RESULT_PENDING_ML, 2) \ + _(XR_WORLD_MESH_BLOCK_RESULT_PARTIAL_UPDATE_ML, 3) \ + _(XR_WORLD_MESH_BLOCK_RESULT_MAX_ENUM_ML, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrFacialBlendShapeML(_) \ + _(XR_FACIAL_BLEND_SHAPE_BROW_LOWERER_L_ML, 0) \ + _(XR_FACIAL_BLEND_SHAPE_BROW_LOWERER_R_ML, 1) \ + _(XR_FACIAL_BLEND_SHAPE_CHEEK_RAISER_L_ML, 2) \ + _(XR_FACIAL_BLEND_SHAPE_CHEEK_RAISER_R_ML, 3) \ + _(XR_FACIAL_BLEND_SHAPE_CHIN_RAISER_ML, 4) \ + _(XR_FACIAL_BLEND_SHAPE_DIMPLER_L_ML, 5) \ + _(XR_FACIAL_BLEND_SHAPE_DIMPLER_R_ML, 6) \ + _(XR_FACIAL_BLEND_SHAPE_EYES_CLOSED_L_ML, 7) \ + _(XR_FACIAL_BLEND_SHAPE_EYES_CLOSED_R_ML, 8) \ + _(XR_FACIAL_BLEND_SHAPE_INNER_BROW_RAISER_L_ML, 9) \ + _(XR_FACIAL_BLEND_SHAPE_INNER_BROW_RAISER_R_ML, 10) \ + _(XR_FACIAL_BLEND_SHAPE_JAW_DROP_ML, 11) \ + _(XR_FACIAL_BLEND_SHAPE_LID_TIGHTENER_L_ML, 12) \ + _(XR_FACIAL_BLEND_SHAPE_LID_TIGHTENER_R_ML, 13) \ + _(XR_FACIAL_BLEND_SHAPE_LIP_CORNER_DEPRESSOR_L_ML, 14) \ + _(XR_FACIAL_BLEND_SHAPE_LIP_CORNER_DEPRESSOR_R_ML, 15) \ + _(XR_FACIAL_BLEND_SHAPE_LIP_CORNER_PULLER_L_ML, 16) \ + _(XR_FACIAL_BLEND_SHAPE_LIP_CORNER_PULLER_R_ML, 17) \ + _(XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_LB_ML, 18) \ + _(XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_LT_ML, 19) \ + _(XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_RB_ML, 20) \ + _(XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_RT_ML, 21) \ + _(XR_FACIAL_BLEND_SHAPE_LIP_PRESSOR_L_ML, 22) \ + _(XR_FACIAL_BLEND_SHAPE_LIP_PRESSOR_R_ML, 23) \ + _(XR_FACIAL_BLEND_SHAPE_LIP_PUCKER_L_ML, 24) \ + _(XR_FACIAL_BLEND_SHAPE_LIP_PUCKER_R_ML, 25) \ + _(XR_FACIAL_BLEND_SHAPE_LIP_STRETCHER_L_ML, 26) \ + _(XR_FACIAL_BLEND_SHAPE_LIP_STRETCHER_R_ML, 27) \ + _(XR_FACIAL_BLEND_SHAPE_LIP_SUCK_LB_ML, 28) \ + _(XR_FACIAL_BLEND_SHAPE_LIP_SUCK_LT_ML, 29) \ + _(XR_FACIAL_BLEND_SHAPE_LIP_SUCK_RB_ML, 30) \ + _(XR_FACIAL_BLEND_SHAPE_LIP_SUCK_RT_ML, 31) \ + _(XR_FACIAL_BLEND_SHAPE_LIP_TIGHTENER_L_ML, 32) \ + _(XR_FACIAL_BLEND_SHAPE_LIP_TIGHTENER_R_ML, 33) \ + _(XR_FACIAL_BLEND_SHAPE_LIPS_TOWARD_ML, 34) \ + _(XR_FACIAL_BLEND_SHAPE_LOWER_LIP_DEPRESSOR_L_ML, 35) \ + _(XR_FACIAL_BLEND_SHAPE_LOWER_LIP_DEPRESSOR_R_ML, 36) \ + _(XR_FACIAL_BLEND_SHAPE_NOSE_WRINKLER_L_ML, 37) \ + _(XR_FACIAL_BLEND_SHAPE_NOSE_WRINKLER_R_ML, 38) \ + _(XR_FACIAL_BLEND_SHAPE_OUTER_BROW_RAISER_L_ML, 39) \ + _(XR_FACIAL_BLEND_SHAPE_OUTER_BROW_RAISER_R_ML, 40) \ + _(XR_FACIAL_BLEND_SHAPE_UPPER_LID_RAISER_L_ML, 41) \ + _(XR_FACIAL_BLEND_SHAPE_UPPER_LID_RAISER_R_ML, 42) \ + _(XR_FACIAL_BLEND_SHAPE_UPPER_LIP_RAISER_L_ML, 43) \ + _(XR_FACIAL_BLEND_SHAPE_UPPER_LIP_RAISER_R_ML, 44) \ + _(XR_FACIAL_BLEND_SHAPE_TONGUE_OUT_ML, 45) \ + _(XR_FACIAL_BLEND_SHAPE_MAX_ENUM_ML, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrBoundaryVisibilityMETA(_) \ + _(XR_BOUNDARY_VISIBILITY_NOT_SUPPRESSED_META, 1) \ + _(XR_BOUNDARY_VISIBILITY_SUPPRESSED_META, 2) \ + _(XR_BOUNDARY_VISIBILITY_MAX_ENUM_META, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrFaceTrackingVisemeMETA(_) \ + _(XR_FACE_TRACKING_VISEME_SIL_META, 0) \ + _(XR_FACE_TRACKING_VISEME_PP_META, 1) \ + _(XR_FACE_TRACKING_VISEME_FF_META, 2) \ + _(XR_FACE_TRACKING_VISEME_TH_META, 3) \ + _(XR_FACE_TRACKING_VISEME_DD_META, 4) \ + _(XR_FACE_TRACKING_VISEME_KK_META, 5) \ + _(XR_FACE_TRACKING_VISEME_CH_META, 6) \ + _(XR_FACE_TRACKING_VISEME_SS_META, 7) \ + _(XR_FACE_TRACKING_VISEME_NN_META, 8) \ + _(XR_FACE_TRACKING_VISEME_RR_META, 9) \ + _(XR_FACE_TRACKING_VISEME_AA_META, 10) \ + _(XR_FACE_TRACKING_VISEME_E_META, 11) \ + _(XR_FACE_TRACKING_VISEME_IH_META, 12) \ + _(XR_FACE_TRACKING_VISEME_OH_META, 13) \ + _(XR_FACE_TRACKING_VISEME_OU_META, 14) \ + _(XR_FACE_TRACKING_VISEME_MAX_ENUM_META, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSemanticLabelMETA(_) \ + _(XR_SEMANTIC_LABEL_UNKNOWN_META, 0) \ + _(XR_SEMANTIC_LABEL_FLOOR_META, 1) \ + _(XR_SEMANTIC_LABEL_CEILING_META, 2) \ + _(XR_SEMANTIC_LABEL_WALL_FACE_META, 3) \ + _(XR_SEMANTIC_LABEL_INNER_WALL_FACE_META, 4) \ + _(XR_SEMANTIC_LABEL_INVISIBLE_WALL_FACE_META, 5) \ + _(XR_SEMANTIC_LABEL_DOOR_FRAME_META, 6) \ + _(XR_SEMANTIC_LABEL_WINDOW_FRAME_META, 7) \ + _(XR_SEMANTIC_LABEL_MAX_ENUM_META, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrEnvironmentRaycastHitStatusMETA(_) \ + _(XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_META, 1) \ + _(XR_ENVIRONMENT_RAYCAST_HIT_STATUS_NO_HIT_META, 2) \ + _(XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_POINT_OCCLUDED_META, 3) \ + _(XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_POINT_OUTSIDE_OF_FOV_META, 4) \ + _(XR_ENVIRONMENT_RAYCAST_HIT_STATUS_RAY_OCCLUDED_META, 5) \ + _(XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_INVALID_ORIENTATION_META, 6) \ + _(XR_ENVIRONMENT_RAYCAST_HIT_STATUS_MAX_ENUM_META, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrHandTrackingFrequencyHintMETA(_) \ + _(XR_HAND_TRACKING_FREQUENCY_HINT_DEFAULT_META, 1) \ + _(XR_HAND_TRACKING_FREQUENCY_HINT_HIGH_META, 2) \ + _(XR_HAND_TRACKING_FREQUENCY_HINT_MAX_ENUM_META, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrLightEstimateStateANDROID(_) \ + _(XR_LIGHT_ESTIMATE_STATE_VALID_ANDROID, 0) \ + _(XR_LIGHT_ESTIMATE_STATE_INVALID_ANDROID, 1) \ + _(XR_LIGHT_ESTIMATE_STATE_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSphericalHarmonicsKindANDROID(_) \ + _(XR_SPHERICAL_HARMONICS_KIND_TOTAL_ANDROID, 0) \ + _(XR_SPHERICAL_HARMONICS_KIND_AMBIENT_ANDROID, 1) \ + _(XR_SPHERICAL_HARMONICS_KIND_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrTrackableMarkerTrackingModeANDROID(_) \ + _(XR_TRACKABLE_MARKER_TRACKING_MODE_DYNAMIC_ANDROID, 0) \ + _(XR_TRACKABLE_MARKER_TRACKING_MODE_STATIC_ANDROID, 1) \ + _(XR_TRACKABLE_MARKER_TRACKING_MODE_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrTrackableMarkerDictionaryANDROID(_) \ + _(XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_50_ANDROID, 0) \ + _(XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_100_ANDROID, 1) \ + _(XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_250_ANDROID, 2) \ + _(XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_1000_ANDROID, 3) \ + _(XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_50_ANDROID, 4) \ + _(XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_100_ANDROID, 5) \ + _(XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_250_ANDROID, 6) \ + _(XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_1000_ANDROID, 7) \ + _(XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_50_ANDROID, 8) \ + _(XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_100_ANDROID, 9) \ + _(XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_250_ANDROID, 10) \ + _(XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_1000_ANDROID, 11) \ + _(XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_50_ANDROID, 12) \ + _(XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_100_ANDROID, 13) \ + _(XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_250_ANDROID, 14) \ + _(XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_1000_ANDROID, 15) \ + _(XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_16H5_ANDROID, 16) \ + _(XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_25H9_ANDROID, 17) \ + _(XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_36H10_ANDROID, 18) \ + _(XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_36H11_ANDROID, 19) \ + _(XR_TRACKABLE_MARKER_DICTIONARY_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrQrCodeTrackingModeANDROID(_) \ + _(XR_QR_CODE_TRACKING_MODE_DYNAMIC_ANDROID, 0) \ + _(XR_QR_CODE_TRACKING_MODE_STATIC_ANDROID, 1) \ + _(XR_QRCODE_TRACKING_MODE_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrTrackableImageTrackingModeANDROID(_) \ + _(XR_TRACKABLE_IMAGE_TRACKING_MODE_DYNAMIC_ANDROID, 1) \ + _(XR_TRACKABLE_IMAGE_TRACKING_MODE_STATIC_ANDROID, 2) \ + _(XR_TRACKABLE_IMAGE_TRACKING_MODE_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrTrackableImageFormatANDROID(_) \ + _(XR_TRACKABLE_IMAGE_FORMAT_R8G8B8A8_ANDROID, 1) \ + _(XR_TRACKABLE_IMAGE_FORMAT_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSceneMeshSemanticLabelSetANDROID(_) \ + _(XR_SCENE_MESH_SEMANTIC_LABEL_SET_NONE_ANDROID, 0) \ + _(XR_SCENE_MESH_SEMANTIC_LABEL_SET_DEFAULT_ANDROID, 1) \ + _(XR_SCENE_MESH_SEMANTIC_LABEL_SET_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSceneMeshTrackingStateANDROID(_) \ + _(XR_SCENE_MESH_TRACKING_STATE_INITIALIZING_ANDROID, 0) \ + _(XR_SCENE_MESH_TRACKING_STATE_TRACKING_ANDROID, 1) \ + _(XR_SCENE_MESH_TRACKING_STATE_WAITING_ANDROID, 2) \ + _(XR_SCENE_MESH_TRACKING_STATE_ERROR_ANDROID, 3) \ + _(XR_SCENE_MESH_TRACKING_STATE_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSceneMeshSemanticLabelANDROID(_) \ + _(XR_SCENE_MESH_SEMANTIC_LABEL_OTHER_ANDROID, 0) \ + _(XR_SCENE_MESH_SEMANTIC_LABEL_FLOOR_ANDROID, 1) \ + _(XR_SCENE_MESH_SEMANTIC_LABEL_CEILING_ANDROID, 2) \ + _(XR_SCENE_MESH_SEMANTIC_LABEL_WALL_ANDROID, 3) \ + _(XR_SCENE_MESH_SEMANTIC_LABEL_TABLE_ANDROID, 4) \ + _(XR_SCENE_MESH_SEMANTIC_LABEL_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpatialCapabilityEXT(_) \ + _(XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT, 1000741000) \ + _(XR_SPATIAL_CAPABILITY_MARKER_TRACKING_QR_CODE_EXT, 1000743000) \ + _(XR_SPATIAL_CAPABILITY_MARKER_TRACKING_MICRO_QR_CODE_EXT, 1000743001) \ + _(XR_SPATIAL_CAPABILITY_MARKER_TRACKING_ARUCO_MARKER_EXT, 1000743002) \ + _(XR_SPATIAL_CAPABILITY_MARKER_TRACKING_APRIL_TAG_EXT, 1000743003) \ + _(XR_SPATIAL_CAPABILITY_ANCHOR_EXT, 1000762000) \ + _(XR_SPATIAL_CAPABILITY_IMAGE_TRACKING_EXT, 1000782000) \ + _(XR_SPATIAL_CAPABILITY_OBJECT_TRACKING_ANDROID, 1000785000) \ + _(XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID, 1000786000) \ + _(XR_SPATIAL_CAPABILITY_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpatialCapabilityFeatureEXT(_) \ + _(XR_SPATIAL_CAPABILITY_FEATURE_MARKER_TRACKING_FIXED_SIZE_MARKERS_EXT, 1000743000) \ + _(XR_SPATIAL_CAPABILITY_FEATURE_MARKER_TRACKING_STATIC_MARKERS_EXT, 1000743001) \ + _(XR_SPATIAL_CAPABILITY_FEATURE_SPHERE_BOUNDS_FILTER_ANDROID, 1000761000) \ + _(XR_SPATIAL_CAPABILITY_FEATURE_BOX_BOUNDS_FILTER_ANDROID, 1000761001) \ + _(XR_SPATIAL_CAPABILITY_FEATURE_FRUSTUM_BOUNDS_FILTER_ANDROID, 1000761002) \ + _(XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_AUTOMATIC_SIZE_IMAGES_EXT, 1000782000) \ + _(XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_STATIC_IMAGES_EXT, 1000782001) \ + _(XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_FIXED_SIZE_IMAGES_EXT, 1000782002) \ + _(XR_SPATIAL_CAPABILITY_FEATURE_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpatialComponentTypeEXT(_) \ + _(XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT, 1) \ + _(XR_SPATIAL_COMPONENT_TYPE_BOUNDED_3D_EXT, 2) \ + _(XR_SPATIAL_COMPONENT_TYPE_PARENT_EXT, 3) \ + _(XR_SPATIAL_COMPONENT_TYPE_MESH_3D_EXT, 4) \ + _(XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT, 1000741000) \ + _(XR_SPATIAL_COMPONENT_TYPE_MESH_2D_EXT, 1000741001) \ + _(XR_SPATIAL_COMPONENT_TYPE_POLYGON_2D_EXT, 1000741002) \ + _(XR_SPATIAL_COMPONENT_TYPE_PLANE_SEMANTIC_LABEL_EXT, 1000741003) \ + _(XR_SPATIAL_COMPONENT_TYPE_MARKER_EXT, 1000743000) \ + _(XR_SPATIAL_COMPONENT_TYPE_ANCHOR_EXT, 1000762000) \ + _(XR_SPATIAL_COMPONENT_TYPE_PERSISTENCE_EXT, 1000763000) \ + _(XR_SPATIAL_COMPONENT_TYPE_IMAGE_2D_EXT, 1000782000) \ + _(XR_SPATIAL_COMPONENT_TYPE_OBJECT_SEMANTIC_LABEL_ANDROID, 1000785000) \ + _(XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID, 1000786000) \ + _(XR_SPATIAL_COMPONENT_TYPE_SUBSUMED_BY_ANDROID, 1000791000) \ + _(XR_SPATIAL_COMPONENT_TYPE_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpatialEntityTrackingStateEXT(_) \ + _(XR_SPATIAL_ENTITY_TRACKING_STATE_STOPPED_EXT, 1) \ + _(XR_SPATIAL_ENTITY_TRACKING_STATE_PAUSED_EXT, 2) \ + _(XR_SPATIAL_ENTITY_TRACKING_STATE_TRACKING_EXT, 3) \ + _(XR_SPATIAL_ENTITY_TRACKING_STATE_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpatialBufferTypeEXT(_) \ + _(XR_SPATIAL_BUFFER_TYPE_UNKNOWN_EXT, 0) \ + _(XR_SPATIAL_BUFFER_TYPE_STRING_EXT, 1) \ + _(XR_SPATIAL_BUFFER_TYPE_UINT8_EXT, 2) \ + _(XR_SPATIAL_BUFFER_TYPE_UINT16_EXT, 3) \ + _(XR_SPATIAL_BUFFER_TYPE_UINT32_EXT, 4) \ + _(XR_SPATIAL_BUFFER_TYPE_FLOAT_EXT, 5) \ + _(XR_SPATIAL_BUFFER_TYPE_VECTOR2F_EXT, 6) \ + _(XR_SPATIAL_BUFFER_TYPE_VECTOR3F_EXT, 7) \ + _(XR_SPATIAL_BUFFER_TYPE_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpatialPlaneAlignmentEXT(_) \ + _(XR_SPATIAL_PLANE_ALIGNMENT_HORIZONTAL_UPWARD_EXT, 0) \ + _(XR_SPATIAL_PLANE_ALIGNMENT_HORIZONTAL_DOWNWARD_EXT, 1) \ + _(XR_SPATIAL_PLANE_ALIGNMENT_VERTICAL_EXT, 2) \ + _(XR_SPATIAL_PLANE_ALIGNMENT_ARBITRARY_EXT, 3) \ + _(XR_SPATIAL_PLANE_ALIGNMENT_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpatialPlaneSemanticLabelEXT(_) \ + _(XR_SPATIAL_PLANE_SEMANTIC_LABEL_UNCATEGORIZED_EXT, 1) \ + _(XR_SPATIAL_PLANE_SEMANTIC_LABEL_FLOOR_EXT, 2) \ + _(XR_SPATIAL_PLANE_SEMANTIC_LABEL_WALL_EXT, 3) \ + _(XR_SPATIAL_PLANE_SEMANTIC_LABEL_CEILING_EXT, 4) \ + _(XR_SPATIAL_PLANE_SEMANTIC_LABEL_TABLE_EXT, 5) \ + _(XR_SPATIAL_PLANE_SEMANTIC_LABEL_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpatialMarkerArucoDictEXT(_) \ + _(XR_SPATIAL_MARKER_ARUCO_DICT_4X4_50_EXT, 1) \ + _(XR_SPATIAL_MARKER_ARUCO_DICT_4X4_100_EXT, 2) \ + _(XR_SPATIAL_MARKER_ARUCO_DICT_4X4_250_EXT, 3) \ + _(XR_SPATIAL_MARKER_ARUCO_DICT_4X4_1000_EXT, 4) \ + _(XR_SPATIAL_MARKER_ARUCO_DICT_5X5_50_EXT, 5) \ + _(XR_SPATIAL_MARKER_ARUCO_DICT_5X5_100_EXT, 6) \ + _(XR_SPATIAL_MARKER_ARUCO_DICT_5X5_250_EXT, 7) \ + _(XR_SPATIAL_MARKER_ARUCO_DICT_5X5_1000_EXT, 8) \ + _(XR_SPATIAL_MARKER_ARUCO_DICT_6X6_50_EXT, 9) \ + _(XR_SPATIAL_MARKER_ARUCO_DICT_6X6_100_EXT, 10) \ + _(XR_SPATIAL_MARKER_ARUCO_DICT_6X6_250_EXT, 11) \ + _(XR_SPATIAL_MARKER_ARUCO_DICT_6X6_1000_EXT, 12) \ + _(XR_SPATIAL_MARKER_ARUCO_DICT_7X7_50_EXT, 13) \ + _(XR_SPATIAL_MARKER_ARUCO_DICT_7X7_100_EXT, 14) \ + _(XR_SPATIAL_MARKER_ARUCO_DICT_7X7_250_EXT, 15) \ + _(XR_SPATIAL_MARKER_ARUCO_DICT_7X7_1000_EXT, 16) \ + _(XR_SPATIAL_MARKER_ARUCO_DICT_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpatialMarkerAprilTagDictEXT(_) \ + _(XR_SPATIAL_MARKER_APRIL_TAG_DICT_16H5_EXT, 1) \ + _(XR_SPATIAL_MARKER_APRIL_TAG_DICT_25H9_EXT, 2) \ + _(XR_SPATIAL_MARKER_APRIL_TAG_DICT_36H10_EXT, 3) \ + _(XR_SPATIAL_MARKER_APRIL_TAG_DICT_36H11_EXT, 4) \ + _(XR_SPATIAL_MARKER_APRIL_TAG_DICT_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrDynamicObjectTypeBD(_) \ + _(XR_DYNAMIC_OBJECT_TYPE_UNKNOWN_BD, 0) \ + _(XR_DYNAMIC_OBJECT_TYPE_KEYBOARD_BD, 1000747000) \ + _(XR_DYNAMIC_OBJECT_TYPE_MOUSE_BD, 1000748000) \ + _(XR_DYNAMIC_OBJECT_TYPE_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrCameraPropertyTypeBD(_) \ + _(XR_CAMERA_PROPERTY_TYPE_FACING_BD, 1) \ + _(XR_CAMERA_PROPERTY_TYPE_POSITION_BD, 2) \ + _(XR_CAMERA_PROPERTY_TYPE_CAMERA_TYPE_BD, 3) \ + _(XR_CAMERA_PROPERTY_TYPE_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrCameraFacingBD(_) \ + _(XR_CAMERA_FACING_WORLD_BD, 1) \ + _(XR_CAMERA_FACING_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrCameraPositionBD(_) \ + _(XR_CAMERA_POSITION_UNSPECIFIED_BD, 1) \ + _(XR_CAMERA_POSITION_LEFT_BD, 2) \ + _(XR_CAMERA_POSITION_RIGHT_BD, 3) \ + _(XR_CAMERA_POSITION_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrCameraTypeBD(_) \ + _(XR_CAMERA_TYPE_PASSTHROUGH_COLOR_BD, 1) \ + _(XR_CAMERA_TYPE_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrCameraCapabilityTypeBD(_) \ + _(XR_CAMERA_CAPABILITY_TYPE_IMAGE_RESOLUTION_AND_FRAME_RATE_BD, 1) \ + _(XR_CAMERA_CAPABILITY_TYPE_IMAGE_FORMAT_BD, 2) \ + _(XR_CAMERA_CAPABILITY_TYPE_DATA_TRANSFER_TYPE_BD, 3) \ + _(XR_CAMERA_CAPABILITY_TYPE_CAMERA_MODEL_BD, 4) \ + _(XR_CAMERA_CAPABILITY_TYPE_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrCameraDataTransferTypeBD(_) \ + _(XR_CAMERA_DATA_TRANSFER_TYPE_RAW_BUFFER_BD, 1) \ + _(XR_CAMERA_DATA_TRANSFER_TYPE_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrCameraImageFormatBD(_) \ + _(XR_CAMERA_IMAGE_FORMAT_RGBA_8888_BD, 1) \ + _(XR_CAMERA_IMAGE_FORMAT_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrCameraModelBD(_) \ + _(XR_CAMERA_MODEL_PINHOLE_BD, 1) \ + _(XR_CAMERA_MODEL_MAX_ENUM_BD, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpatialPersistenceScopeEXT(_) \ + _(XR_SPATIAL_PERSISTENCE_SCOPE_SYSTEM_MANAGED_EXT, 1) \ + _(XR_SPATIAL_PERSISTENCE_SCOPE_LOCAL_ANCHORS_EXT, 1000781000) \ + _(XR_SPATIAL_PERSISTENCE_SCOPE_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpatialPersistenceContextResultEXT(_) \ + _(XR_SPATIAL_PERSISTENCE_CONTEXT_RESULT_SUCCESS_EXT, 0) \ + _(XR_SPATIAL_PERSISTENCE_CONTEXT_RESULT_ENTITY_NOT_TRACKING_EXT, -1000781001) \ + _(XR_SPATIAL_PERSISTENCE_CONTEXT_RESULT_PERSIST_UUID_NOT_FOUND_EXT, -1000781002) \ + _(XR_SPATIAL_PERSISTENCE_CONTEXT_RESULT_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpatialPersistenceStateEXT(_) \ + _(XR_SPATIAL_PERSISTENCE_STATE_LOADED_EXT, 1) \ + _(XR_SPATIAL_PERSISTENCE_STATE_NOT_FOUND_EXT, 2) \ + _(XR_SPATIAL_PERSISTENCE_STATE_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrHapticParametricStreamFrameTypeEXT(_) \ + _(XR_HAPTIC_PARAMETRIC_STREAM_FRAME_TYPE_NONE_EXT, 0) \ + _(XR_HAPTIC_PARAMETRIC_STREAM_FRAME_TYPE_FIRST_FRAME_EXT, 1) \ + _(XR_HAPTIC_PARAMETRIC_STREAM_FRAME_TYPE_INTERMEDIATE_FRAME_EXT, 2) \ + _(XR_HAPTIC_PARAMETRIC_STREAM_FRAME_TYPE_LAST_FRAME_EXT, 3) \ + _(XR_HAPTIC_PARAMETRIC_STREAM_FRAME_TYPE_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrColorSpaceSONY(_) \ + _(XR_COLOR_SPACE_SRGB_NONLINEAR_SONY, 0) \ + _(XR_COLOR_SPACE_DISPLAY_P3_LINEAR_SONY, 1) \ + _(XR_COLOR_SPACE_DISPLAY_P3_NONLINEAR_SONY, 2) \ + _(XR_COLOR_SPACE_DCI_P3_LINEAR_SONY, 3) \ + _(XR_COLOR_SPACE_DCI_P3_NONLINEAR_SONY, 4) \ + _(XR_COLOR_SPACE_EXTENDED_SRGB_LINEAR_SONY, 5) \ + _(XR_COLOR_SPACE_BT709_LINEAR_SONY, 6) \ + _(XR_COLOR_SPACE_BT709_NONLINEAR_SONY, 7) \ + _(XR_COLOR_SPACE_BT2020_LINEAR_SONY, 8) \ + _(XR_COLOR_SPACE_BT2020_PQ_SONY, 9) \ + _(XR_COLOR_SPACE_BT2020_HLG_SONY, 10) \ + _(XR_COLOR_SPACE_MAX_ENUM_SONY, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpatialReferenceImageFormatEXT(_) \ + _(XR_SPATIAL_REFERENCE_IMAGE_FORMAT_RGBA_8888_EXT, 1) \ + _(XR_SPATIAL_REFERENCE_IMAGE_FORMAT_RGB_888_EXT, 2) \ + _(XR_SPATIAL_REFERENCE_IMAGE_FORMAT_YUV_420_888_EXT, 3) \ + _(XR_SPATIAL_REFERENCE_IMAGE_FORMAT_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpatialObjectSemanticLabelANDROID(_) \ + _(XR_SPATIAL_OBJECT_SEMANTIC_LABEL_UNCATEGORIZED_ANDROID, 0) \ + _(XR_SPATIAL_OBJECT_SEMANTIC_LABEL_KEYBOARD_ANDROID, 1) \ + _(XR_SPATIAL_OBJECT_SEMANTIC_LABEL_MOUSE_ANDROID, 2) \ + _(XR_SPATIAL_OBJECT_SEMANTIC_LABEL_LAPTOP_BASE_ANDROID, 3) \ + _(XR_SPATIAL_OBJECT_SEMANTIC_LABEL_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrGoogleCloudAuthErrorANDROID(_) \ + _(XR_GOOGLE_CLOUD_AUTH_ERROR_NONE_ANDROID, 0) \ + _(XR_GOOGLE_CLOUD_AUTH_ERROR_QUOTA_EXCEEDED_ANDROID, -1) \ + _(XR_GOOGLE_CLOUD_AUTH_ERROR_UNREACHABLE_ANDROID, -2) \ + _(XR_GOOGLE_CLOUD_AUTH_ERROR_ANDROID, -3) \ + _(XR_GOOGLE_CLOUD_AUTH_ERROR_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrGeospatialTrackerStateANDROID(_) \ + _(XR_GEOSPATIAL_TRACKER_STATE_STOPPED_ANDROID, 0) \ + _(XR_GEOSPATIAL_TRACKER_STATE_RUNNING_ANDROID, 1) \ + _(XR_GEOSPATIAL_TRACKER_STATE_INITIALIZATION_FAILED_ANDROID, 2) \ + _(XR_GEOSPATIAL_TRACKER_STATE_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrVPSAvailabilityANDROID(_) \ + _(XR_VPS_AVAILABILITY_UNAVAILABLE_ANDROID, 1) \ + _(XR_VPS_AVAILABILITY_AVAILABLE_ANDROID, 2) \ + _(XR_VPSAVAILABILITY_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSurfaceAnchorTypeANDROID(_) \ + _(XR_SURFACE_ANCHOR_TYPE_TERRAIN_ANDROID, 1) \ + _(XR_SURFACE_ANCHOR_TYPE_ROOFTOP_ANDROID, 2) \ + _(XR_SURFACE_ANCHOR_TYPE_MAX_ENUM_ANDROID, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpatialContainerGraphicsPresentationEXT(_) \ + _(XR_SPATIAL_CONTAINER_GRAPHICS_PRESENTATION_SELF_RENDERING_EXT, 1000813000) \ + _(XR_SPATIAL_CONTAINER_GRAPHICS_PRESENTATION_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpatialContainerBoundsModeEXT(_) \ + _(XR_SPATIAL_CONTAINER_BOUNDS_MODE_BOUNDED_EXT, 1) \ + _(XR_SPATIAL_CONTAINER_BOUNDS_MODE_IMMERSIVE_EXT, 2) \ + _(XR_SPATIAL_CONTAINER_BOUNDS_MODE_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_ENUM_XrSpatialContainerVolumeClippingEXT(_) \ + _(XR_SPATIAL_CONTAINER_VOLUME_CLIPPING_NONE_EXT, 0) \ + _(XR_SPATIAL_CONTAINER_VOLUME_CLIPPING_STRICT_EXT, 1) \ + _(XR_SPATIAL_CONTAINER_VOLUME_CLIPPING_MAX_ENUM_EXT, 0x7FFFFFFF) + +#define XR_LIST_BITS_XrInstanceCreateFlags(_) + +#define XR_LIST_BITS_XrSessionCreateFlags(_) + +#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_XrSpaceVelocityFlags(_) \ + _(XR_SPACE_VELOCITY_LINEAR_VALID_BIT, 0x00000001) \ + _(XR_SPACE_VELOCITY_ANGULAR_VALID_BIT, 0x00000002) \ + +#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) \ + _(XR_COMPOSITION_LAYER_INVERTED_ALPHA_BIT_EXT, 0x00000008) \ + +#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_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_XrAndroidSurfaceSwapchainFlagsFB(_) \ + _(XR_ANDROID_SURFACE_SWAPCHAIN_SYNCHRONOUS_BIT_FB, 0x00000001) \ + _(XR_ANDROID_SURFACE_SWAPCHAIN_USE_TIMESTAMPS_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_XrPassthroughCapabilityFlagsFB(_) \ + _(XR_PASSTHROUGH_CAPABILITY_BIT_FB, 0x00000001) \ + _(XR_PASSTHROUGH_CAPABILITY_COLOR_BIT_FB, 0x00000002) \ + _(XR_PASSTHROUGH_CAPABILITY_LAYER_DEPTH_BIT_FB, 0x00000004) \ + +#define XR_LIST_BITS_XrPassthroughFlagsFB(_) \ + _(XR_PASSTHROUGH_IS_RUNNING_AT_CREATION_BIT_FB, 0x00000001) \ + _(XR_PASSTHROUGH_LAYER_DEPTH_BIT_FB, 0x00000002) \ + +#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(_) \ + _(XR_RENDER_MODEL_SUPPORTS_GLTF_2_0_SUBSET_1_BIT_FB, 0x00000001) \ + _(XR_RENDER_MODEL_SUPPORTS_GLTF_2_0_SUBSET_2_BIT_FB, 0x00000002) \ + +#define XR_LIST_BITS_XrFrameEndInfoFlagsML(_) \ + _(XR_FRAME_END_INFO_PROTECTED_BIT_ML, 0x00000001) \ + _(XR_FRAME_END_INFO_VIGNETTE_BIT_ML, 0x00000002) \ + +#define XR_LIST_BITS_XrGlobalDimmerFrameEndInfoFlagsML(_) \ + _(XR_GLOBAL_DIMMER_FRAME_END_INFO_ENABLED_BIT_ML, 0x00000001) \ + +#define XR_LIST_BITS_XrLocalizationMapErrorFlagsML(_) \ + _(XR_LOCALIZATION_MAP_ERROR_UNKNOWN_BIT_ML, 0x00000001) \ + _(XR_LOCALIZATION_MAP_ERROR_OUT_OF_MAPPED_AREA_BIT_ML, 0x00000002) \ + _(XR_LOCALIZATION_MAP_ERROR_LOW_FEATURE_COUNT_BIT_ML, 0x00000004) \ + _(XR_LOCALIZATION_MAP_ERROR_EXCESSIVE_MOTION_BIT_ML, 0x00000008) \ + _(XR_LOCALIZATION_MAP_ERROR_LOW_LIGHT_BIT_ML, 0x00000010) \ + _(XR_LOCALIZATION_MAP_ERROR_HEADPOSE_BIT_ML, 0x00000020) \ + +#define XR_LIST_BITS_XrCompositionLayerSpaceWarpInfoFlagsFB(_) \ + _(XR_COMPOSITION_LAYER_SPACE_WARP_INFO_FRAME_SKIP_BIT_FB, 0x00000001) \ + +#define XR_LIST_BITS_XrSemanticLabelsSupportFlagsFB(_) \ + _(XR_SEMANTIC_LABELS_SUPPORT_MULTIPLE_SEMANTIC_LABELS_BIT_FB, 0x00000001) \ + _(XR_SEMANTIC_LABELS_SUPPORT_ACCEPT_DESK_TO_TABLE_MIGRATION_BIT_FB, 0x00000002) \ + _(XR_SEMANTIC_LABELS_SUPPORT_ACCEPT_INVISIBLE_WALL_FACE_BIT_FB, 0x00000004) \ + +#define XR_LIST_BITS_XrDigitalLensControlFlagsALMALENCE(_) \ + _(XR_DIGITAL_LENS_CONTROL_PROCESSING_DISABLE_BIT_ALMALENCE, 0x00000001) \ + +#define XR_LIST_BITS_XrFoveationEyeTrackedProfileCreateFlagsMETA(_) + +#define XR_LIST_BITS_XrFoveationEyeTrackedStateFlagsMETA(_) \ + _(XR_FOVEATION_EYE_TRACKED_STATE_VALID_BIT_META, 0x00000001) \ + +#define XR_LIST_BITS_XrCompositionLayerSettingsFlagsFB(_) \ + _(XR_COMPOSITION_LAYER_SETTINGS_NORMAL_SUPER_SAMPLING_BIT_FB, 0x00000001) \ + _(XR_COMPOSITION_LAYER_SETTINGS_QUALITY_SUPER_SAMPLING_BIT_FB, 0x00000002) \ + _(XR_COMPOSITION_LAYER_SETTINGS_NORMAL_SHARPENING_BIT_FB, 0x00000004) \ + _(XR_COMPOSITION_LAYER_SETTINGS_QUALITY_SHARPENING_BIT_FB, 0x00000008) \ + _(XR_COMPOSITION_LAYER_SETTINGS_AUTO_LAYER_FILTER_BIT_META, 0x00000020) \ + +#define XR_LIST_BITS_XrFrameSynthesisInfoFlagsEXT(_) \ + _(XR_FRAME_SYNTHESIS_INFO_USE_2D_MOTION_VECTOR_BIT_EXT, 0x00000001) \ + _(XR_FRAME_SYNTHESIS_INFO_REQUEST_RELAXED_FRAME_INTERVAL_BIT_EXT, 0x00000002) \ + +#define XR_LIST_BITS_XrPassthroughPreferenceFlagsMETA(_) \ + _(XR_PASSTHROUGH_PREFERENCE_DEFAULT_TO_ACTIVE_BIT_META, 0x00000001) \ + +#define XR_LIST_BITS_XrVirtualKeyboardInputStateFlagsMETA(_) \ + _(XR_VIRTUAL_KEYBOARD_INPUT_STATE_PRESSED_BIT_META, 0x00000001) \ + +#define XR_LIST_BITS_XrExternalCameraStatusFlagsOCULUS(_) \ + _(XR_EXTERNAL_CAMERA_STATUS_CONNECTED_BIT_OCULUS, 0x00000001) \ + _(XR_EXTERNAL_CAMERA_STATUS_CALIBRATING_BIT_OCULUS, 0x00000002) \ + _(XR_EXTERNAL_CAMERA_STATUS_CALIBRATION_FAILED_BIT_OCULUS, 0x00000004) \ + _(XR_EXTERNAL_CAMERA_STATUS_CALIBRATED_BIT_OCULUS, 0x00000008) \ + _(XR_EXTERNAL_CAMERA_STATUS_CAPTURING_BIT_OCULUS, 0x00000010) \ + +#define XR_LIST_BITS_XrPerformanceMetricsCounterFlagsMETA(_) \ + _(XR_PERFORMANCE_METRICS_COUNTER_ANY_VALUE_VALID_BIT_META, 0x00000001) \ + _(XR_PERFORMANCE_METRICS_COUNTER_UINT_VALUE_VALID_BIT_META, 0x00000002) \ + _(XR_PERFORMANCE_METRICS_COUNTER_FLOAT_VALUE_VALID_BIT_META, 0x00000004) \ + +#define XR_LIST_BITS_XrEnvironmentDepthProviderCreateFlagsMETA(_) + +#define XR_LIST_BITS_XrEnvironmentDepthSwapchainCreateFlagsMETA(_) + +#define XR_LIST_BITS_XrFoveationDynamicFlagsHTC(_) \ + _(XR_FOVEATION_DYNAMIC_LEVEL_ENABLED_BIT_HTC, 0x00000001) \ + _(XR_FOVEATION_DYNAMIC_CLEAR_FOV_ENABLED_BIT_HTC, 0x00000002) \ + _(XR_FOVEATION_DYNAMIC_FOCAL_CENTER_OFFSET_ENABLED_BIT_HTC, 0x00000004) \ + +#define XR_LIST_BITS_XrSpatialMeshConfigFlagsBD(_) \ + _(XR_SPATIAL_MESH_CONFIG_SEMANTIC_BIT_BD, 0x00000001) \ + _(XR_SPATIAL_MESH_CONFIG_ALIGN_SEMANTIC_WITH_VERTEX_BIT_BD, 0x00000002) \ + +#define XR_LIST_BITS_XrSpaceAccelerationFlagsBD(_) \ + _(XR_SPACE_ACCELERATION_LINEAR_VALID_BIT_BD, 0x00000001) \ + _(XR_SPACE_ACCELERATION_ANGULAR_VALID_BIT_BD, 0x00000002) \ + +#define XR_LIST_BITS_XrLightEstimationCreateFlagsBD(_) \ + _(XR_LIGHT_ESTIMATION_CREATE_SPHERICAL_HARMONICS_BIT_BD, 0x00000001) \ + _(XR_LIGHT_ESTIMATION_CREATE_ENVIRONMENT_TEXTURE_BIT_BD, 0x00000002) \ + +#define XR_LIST_BITS_XrSoundObstacleFlagsBD(_) \ + _(XR_SOUND_OBSTACLE_ENABLED_BIT_BD, 0x00000001) \ + _(XR_SOUND_OBSTACLE_POSE_BIT_BD, 0x00000002) \ + _(XR_SOUND_OBSTACLE_MESH_BIT_BD, 0x00000004) \ + _(XR_SOUND_OBSTACLE_MATERIALS_BIT_BD, 0x00000008) \ + +#define XR_LIST_BITS_XrSoundObjectFlagsBD(_) \ + _(XR_SOUND_OBJECT_ENABLED_BIT_BD, 0x00000001) \ + _(XR_SOUND_OBJECT_POSE_BIT_BD, 0x00000002) \ + _(XR_SOUND_OBJECT_DIRECTIVITY_BIT_BD, 0x00000004) \ + _(XR_SOUND_OBJECT_SHAPE_BIT_BD, 0x00000008) \ + _(XR_SOUND_OBJECT_MAIN_VOLUME_BIT_BD, 0x00000010) \ + _(XR_SOUND_OBJECT_REFLECTION_GAIN_BIT_BD, 0x00000020) \ + _(XR_SOUND_OBJECT_ENABLE_DOPPLER_BIT_BD, 0x00000040) \ + _(XR_SOUND_OBJECT_DIRECT_SOUND_ATTENUATION_BIT_BD, 0x00000080) \ + _(XR_SOUND_OBJECT_INDIRECT_SOUND_ATTENUATION_BIT_BD, 0x00000100) \ + +#define XR_LIST_BITS_XrSoundFieldFlagsBD(_) \ + _(XR_SOUND_FIELD_ENABLED_BIT_BD, 0x00000001) \ + _(XR_SOUND_FIELD_ORIENTATION_BIT_BD, 0x00000002) \ + _(XR_SOUND_FIELD_MAIN_VOLUME_BIT_BD, 0x00000004) \ + _(XR_SOUND_FIELD_LFE_GAIN_BIT_BD, 0x00000008) \ + +#define XR_LIST_BITS_XrPlaneDetectionCapabilityFlagsEXT(_) \ + _(XR_PLANE_DETECTION_CAPABILITY_PLANE_DETECTION_BIT_EXT, 0x00000001) \ + _(XR_PLANE_DETECTION_CAPABILITY_PLANE_HOLES_BIT_EXT, 0x00000002) \ + _(XR_PLANE_DETECTION_CAPABILITY_SEMANTIC_CEILING_BIT_EXT, 0x00000004) \ + _(XR_PLANE_DETECTION_CAPABILITY_SEMANTIC_FLOOR_BIT_EXT, 0x00000008) \ + _(XR_PLANE_DETECTION_CAPABILITY_SEMANTIC_WALL_BIT_EXT, 0x00000010) \ + _(XR_PLANE_DETECTION_CAPABILITY_SEMANTIC_PLATFORM_BIT_EXT, 0x00000020) \ + _(XR_PLANE_DETECTION_CAPABILITY_ORIENTATION_BIT_EXT, 0x00000040) \ + +#define XR_LIST_BITS_XrPlaneDetectorFlagsEXT(_) \ + _(XR_PLANE_DETECTOR_ENABLE_CONTOUR_BIT_EXT, 0x00000001) \ + +#define XR_LIST_BITS_XrPerformanceMetricsCounterFlagsANDROID(_) \ + _(XR_PERFORMANCE_METRICS_COUNTER_ANY_VALUE_VALID_BIT_ANDROID, 0x00000001) \ + _(XR_PERFORMANCE_METRICS_COUNTER_UINT_VALUE_VALID_BIT_ANDROID, 0x00000002) \ + _(XR_PERFORMANCE_METRICS_COUNTER_FLOAT_VALUE_VALID_BIT_ANDROID, 0x00000004) \ + +#define XR_LIST_BITS_XrWorldMeshDetectorFlagsML(_) \ + _(XR_WORLD_MESH_DETECTOR_POINT_CLOUD_BIT_ML, 0x00000001) \ + _(XR_WORLD_MESH_DETECTOR_COMPUTE_NORMALS_BIT_ML, 0x00000002) \ + _(XR_WORLD_MESH_DETECTOR_COMPUTE_CONFIDENCE_BIT_ML, 0x00000004) \ + _(XR_WORLD_MESH_DETECTOR_PLANARIZE_BIT_ML, 0x00000008) \ + _(XR_WORLD_MESH_DETECTOR_REMOVE_MESH_SKIRT_BIT_ML, 0x00000010) \ + _(XR_WORLD_MESH_DETECTOR_INDEX_ORDER_CW_BIT_ML, 0x00000020) \ + +#define XR_LIST_BITS_XrFacialExpressionBlendShapePropertiesFlagsML(_) \ + _(XR_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_VALID_BIT_ML, 0x00000001) \ + _(XR_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_TRACKED_BIT_ML, 0x00000002) \ + +#define XR_LIST_BITS_XrGeospatialPoseFlagsANDROID(_) \ + _(XR_GEOSPATIAL_POSE_ORIENTATION_VALID_BIT_ANDROID, 0x00000001) \ + _(XR_GEOSPATIAL_POSE_POSITION_VALID_BIT_ANDROID, 0x00000002) \ + +#define XR_LIST_BITS_XrBatteryStateDisplayStateFlagsEXT(_) \ + _(XR_BATTERY_STATE_DISPLAY_STATE_VALID_BIT_EXT, 0x00000001) \ + _(XR_BATTERY_STATE_DISPLAY_STATE_CHARGING_BIT_EXT, 0x00000002) \ + _(XR_BATTERY_STATE_DISPLAY_STATE_PLUGGED_IN_BIT_EXT, 0x00000004) \ + _(XR_BATTERY_STATE_DISPLAY_STATE_NO_BATTERY_BIT_EXT, 0x00000008) \ + +/// Calls your macro with the name of each member of XrApiLayerProperties, in order. +#define XR_LIST_STRUCT_XrApiLayerProperties(_) \ + _(type) \ + _(next) \ + _(layerName) \ + _(specVersion) \ + _(layerVersion) \ + _(description) \ + +/// Calls your macro with the name of each member of XrExtensionProperties, in order. +#define XR_LIST_STRUCT_XrExtensionProperties(_) \ + _(type) \ + _(next) \ + _(extensionName) \ + _(extensionVersion) \ + +/// Calls your macro with the name of each member of XrApplicationInfo, in order. +#define XR_LIST_STRUCT_XrApplicationInfo(_) \ + _(applicationName) \ + _(applicationVersion) \ + _(engineName) \ + _(engineVersion) \ + _(apiVersion) \ + +/// Calls your macro with the name of each member of XrInstanceCreateInfo, in order. +#define XR_LIST_STRUCT_XrInstanceCreateInfo(_) \ + _(type) \ + _(next) \ + _(createFlags) \ + _(applicationInfo) \ + _(enabledApiLayerCount) \ + _(enabledApiLayerNames) \ + _(enabledExtensionCount) \ + _(enabledExtensionNames) \ + +/// Calls your macro with the name of each member of XrInstanceProperties, in order. +#define XR_LIST_STRUCT_XrInstanceProperties(_) \ + _(type) \ + _(next) \ + _(runtimeVersion) \ + _(runtimeName) \ + +/// Calls your macro with the name of each member of XrEventDataBuffer, in order. +#define XR_LIST_STRUCT_XrEventDataBuffer(_) \ + _(type) \ + _(next) \ + _(varying) \ + +/// Calls your macro with the name of each member of XrSystemGetInfo, in order. +#define XR_LIST_STRUCT_XrSystemGetInfo(_) \ + _(type) \ + _(next) \ + _(formFactor) \ + +/// Calls your macro with the name of each member of XrSystemGraphicsProperties, in order. +#define XR_LIST_STRUCT_XrSystemGraphicsProperties(_) \ + _(maxSwapchainImageHeight) \ + _(maxSwapchainImageWidth) \ + _(maxLayerCount) \ + +/// Calls your macro with the name of each member of XrSystemTrackingProperties, in order. +#define XR_LIST_STRUCT_XrSystemTrackingProperties(_) \ + _(orientationTracking) \ + _(positionTracking) \ + +/// Calls your macro with the name of each member of XrSystemProperties, in order. +#define XR_LIST_STRUCT_XrSystemProperties(_) \ + _(type) \ + _(next) \ + _(systemId) \ + _(vendorId) \ + _(systemName) \ + _(graphicsProperties) \ + _(trackingProperties) \ + +/// Calls your macro with the name of each member of XrSessionCreateInfo, in order. +#define XR_LIST_STRUCT_XrSessionCreateInfo(_) \ + _(type) \ + _(next) \ + _(createFlags) \ + _(systemId) \ + +/// Calls your macro with the name of each member of XrQuaternionf, in order. +#define XR_LIST_STRUCT_XrQuaternionf(_) \ + _(x) \ + _(y) \ + _(z) \ + _(w) \ + +/// Calls your macro with the name of each member of XrVector3f, in order. +#define XR_LIST_STRUCT_XrVector3f(_) \ + _(x) \ + _(y) \ + _(z) \ + +/// Calls your macro with the name of each member of XrPosef, in order. +#define XR_LIST_STRUCT_XrPosef(_) \ + _(orientation) \ + _(position) \ + +/// Calls your macro with the name of each member of XrReferenceSpaceCreateInfo, in order. +#define XR_LIST_STRUCT_XrReferenceSpaceCreateInfo(_) \ + _(type) \ + _(next) \ + _(referenceSpaceType) \ + _(poseInReferenceSpace) \ + +/// Calls your macro with the name of each member of XrActionSpaceCreateInfo, in order. +#define XR_LIST_STRUCT_XrActionSpaceCreateInfo(_) \ + _(type) \ + _(next) \ + _(action) \ + _(subactionPath) \ + _(poseInActionSpace) \ + +/// Calls your macro with the name of each member of XrSpaceLocation, in order. +#define XR_LIST_STRUCT_XrSpaceLocation(_) \ + _(type) \ + _(next) \ + _(locationFlags) \ + _(pose) \ + +/// Calls your macro with the name of each member of XrSpaceVelocity, in order. +#define XR_LIST_STRUCT_XrSpaceVelocity(_) \ + _(type) \ + _(next) \ + _(velocityFlags) \ + _(linearVelocity) \ + _(angularVelocity) \ + +/// Calls your macro with the name of each member of XrExtent2Df, in order. +#define XR_LIST_STRUCT_XrExtent2Df(_) \ + _(width) \ + _(height) \ + +/// Calls your macro with the name of each member of XrViewConfigurationProperties, in order. +#define XR_LIST_STRUCT_XrViewConfigurationProperties(_) \ + _(type) \ + _(next) \ + _(viewConfigurationType) \ + _(fovMutable) \ + +/// Calls your macro with the name of each member of XrViewConfigurationView, in order. +#define XR_LIST_STRUCT_XrViewConfigurationView(_) \ + _(type) \ + _(next) \ + _(recommendedImageRectWidth) \ + _(maxImageRectWidth) \ + _(recommendedImageRectHeight) \ + _(maxImageRectHeight) \ + _(recommendedSwapchainSampleCount) \ + _(maxSwapchainSampleCount) \ + +/// Calls your macro with the name of each member of XrSwapchainCreateInfo, in order. +#define XR_LIST_STRUCT_XrSwapchainCreateInfo(_) \ + _(type) \ + _(next) \ + _(createFlags) \ + _(usageFlags) \ + _(format) \ + _(sampleCount) \ + _(width) \ + _(height) \ + _(faceCount) \ + _(arraySize) \ + _(mipCount) \ + +/// Calls your macro with the name of each member of XrSwapchainImageBaseHeader, in order. +#define XR_LIST_STRUCT_XrSwapchainImageBaseHeader(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSwapchainImageAcquireInfo, in order. +#define XR_LIST_STRUCT_XrSwapchainImageAcquireInfo(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSwapchainImageWaitInfo, in order. +#define XR_LIST_STRUCT_XrSwapchainImageWaitInfo(_) \ + _(type) \ + _(next) \ + _(timeout) \ + +/// Calls your macro with the name of each member of XrSwapchainImageReleaseInfo, in order. +#define XR_LIST_STRUCT_XrSwapchainImageReleaseInfo(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSessionBeginInfo, in order. +#define XR_LIST_STRUCT_XrSessionBeginInfo(_) \ + _(type) \ + _(next) \ + _(primaryViewConfigurationType) \ + +/// Calls your macro with the name of each member of XrFrameState, in order. +#define XR_LIST_STRUCT_XrFrameState(_) \ + _(type) \ + _(next) \ + _(predictedDisplayTime) \ + _(predictedDisplayPeriod) \ + _(shouldRender) \ + +/// Calls your macro with the name of each member of XrFrameWaitInfo, in order. +#define XR_LIST_STRUCT_XrFrameWaitInfo(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrFrameBeginInfo, in order. +#define XR_LIST_STRUCT_XrFrameBeginInfo(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrCompositionLayerBaseHeader, in order. +#define XR_LIST_STRUCT_XrCompositionLayerBaseHeader(_) \ + _(type) \ + _(next) \ + _(layerFlags) \ + _(space) \ + +/// Calls your macro with the name of each member of XrFrameEndInfo, in order. +#define XR_LIST_STRUCT_XrFrameEndInfo(_) \ + _(type) \ + _(next) \ + _(displayTime) \ + _(environmentBlendMode) \ + _(layerCount) \ + _(layers) \ + +/// Calls your macro with the name of each member of XrViewState, in order. +#define XR_LIST_STRUCT_XrViewState(_) \ + _(type) \ + _(next) \ + _(viewStateFlags) \ + +/// Calls your macro with the name of each member of XrViewLocateInfo, in order. +#define XR_LIST_STRUCT_XrViewLocateInfo(_) \ + _(type) \ + _(next) \ + _(viewConfigurationType) \ + _(displayTime) \ + _(space) \ + +/// Calls your macro with the name of each member of XrFovf, in order. +#define XR_LIST_STRUCT_XrFovf(_) \ + _(angleLeft) \ + _(angleRight) \ + _(angleUp) \ + _(angleDown) \ + +/// Calls your macro with the name of each member of XrView, in order. +#define XR_LIST_STRUCT_XrView(_) \ + _(type) \ + _(next) \ + _(pose) \ + _(fov) \ + +/// Calls your macro with the name of each member of XrActionSetCreateInfo, in order. +#define XR_LIST_STRUCT_XrActionSetCreateInfo(_) \ + _(type) \ + _(next) \ + _(actionSetName) \ + _(localizedActionSetName) \ + _(priority) \ + +/// Calls your macro with the name of each member of XrActionCreateInfo, in order. +#define XR_LIST_STRUCT_XrActionCreateInfo(_) \ + _(type) \ + _(next) \ + _(actionName) \ + _(actionType) \ + _(countSubactionPaths) \ + _(subactionPaths) \ + _(localizedActionName) \ + +/// Calls your macro with the name of each member of XrActionSuggestedBinding, in order. +#define XR_LIST_STRUCT_XrActionSuggestedBinding(_) \ + _(action) \ + _(binding) \ + +/// Calls your macro with the name of each member of XrInteractionProfileSuggestedBinding, in order. +#define XR_LIST_STRUCT_XrInteractionProfileSuggestedBinding(_) \ + _(type) \ + _(next) \ + _(interactionProfile) \ + _(countSuggestedBindings) \ + _(suggestedBindings) \ + +/// Calls your macro with the name of each member of XrSessionActionSetsAttachInfo, in order. +#define XR_LIST_STRUCT_XrSessionActionSetsAttachInfo(_) \ + _(type) \ + _(next) \ + _(countActionSets) \ + _(actionSets) \ + +/// Calls your macro with the name of each member of XrInteractionProfileState, in order. +#define XR_LIST_STRUCT_XrInteractionProfileState(_) \ + _(type) \ + _(next) \ + _(interactionProfile) \ + +/// Calls your macro with the name of each member of XrActionStateGetInfo, in order. +#define XR_LIST_STRUCT_XrActionStateGetInfo(_) \ + _(type) \ + _(next) \ + _(action) \ + _(subactionPath) \ + +/// Calls your macro with the name of each member of XrActionStateBoolean, in order. +#define XR_LIST_STRUCT_XrActionStateBoolean(_) \ + _(type) \ + _(next) \ + _(currentState) \ + _(changedSinceLastSync) \ + _(lastChangeTime) \ + _(isActive) \ + +/// Calls your macro with the name of each member of XrActionStateFloat, in order. +#define XR_LIST_STRUCT_XrActionStateFloat(_) \ + _(type) \ + _(next) \ + _(currentState) \ + _(changedSinceLastSync) \ + _(lastChangeTime) \ + _(isActive) \ + +/// Calls your macro with the name of each member of XrVector2f, in order. +#define XR_LIST_STRUCT_XrVector2f(_) \ + _(x) \ + _(y) \ + +/// Calls your macro with the name of each member of XrActionStateVector2f, in order. +#define XR_LIST_STRUCT_XrActionStateVector2f(_) \ + _(type) \ + _(next) \ + _(currentState) \ + _(changedSinceLastSync) \ + _(lastChangeTime) \ + _(isActive) \ + +/// Calls your macro with the name of each member of XrActionStatePose, in order. +#define XR_LIST_STRUCT_XrActionStatePose(_) \ + _(type) \ + _(next) \ + _(isActive) \ + +/// Calls your macro with the name of each member of XrActiveActionSet, in order. +#define XR_LIST_STRUCT_XrActiveActionSet(_) \ + _(actionSet) \ + _(subactionPath) \ + +/// Calls your macro with the name of each member of XrActionsSyncInfo, in order. +#define XR_LIST_STRUCT_XrActionsSyncInfo(_) \ + _(type) \ + _(next) \ + _(countActiveActionSets) \ + _(activeActionSets) \ + +/// Calls your macro with the name of each member of XrBoundSourcesForActionEnumerateInfo, in order. +#define XR_LIST_STRUCT_XrBoundSourcesForActionEnumerateInfo(_) \ + _(type) \ + _(next) \ + _(action) \ + +/// Calls your macro with the name of each member of XrInputSourceLocalizedNameGetInfo, in order. +#define XR_LIST_STRUCT_XrInputSourceLocalizedNameGetInfo(_) \ + _(type) \ + _(next) \ + _(sourcePath) \ + _(whichComponents) \ + +/// Calls your macro with the name of each member of XrHapticBaseHeader, in order. +#define XR_LIST_STRUCT_XrHapticBaseHeader(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrHapticActionInfo, in order. +#define XR_LIST_STRUCT_XrHapticActionInfo(_) \ + _(type) \ + _(next) \ + _(action) \ + _(subactionPath) \ + +/// Calls your macro with the name of each member of XrBaseInStructure, in order. +#define XR_LIST_STRUCT_XrBaseInStructure(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrBaseOutStructure, in order. +#define XR_LIST_STRUCT_XrBaseOutStructure(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrOffset2Di, in order. +#define XR_LIST_STRUCT_XrOffset2Di(_) \ + _(x) \ + _(y) \ + +/// Calls your macro with the name of each member of XrExtent2Di, in order. +#define XR_LIST_STRUCT_XrExtent2Di(_) \ + _(width) \ + _(height) \ + +/// Calls your macro with the name of each member of XrRect2Di, in order. +#define XR_LIST_STRUCT_XrRect2Di(_) \ + _(offset) \ + _(extent) \ + +/// Calls your macro with the name of each member of XrSwapchainSubImage, in order. +#define XR_LIST_STRUCT_XrSwapchainSubImage(_) \ + _(swapchain) \ + _(imageRect) \ + _(imageArrayIndex) \ + +/// Calls your macro with the name of each member of XrCompositionLayerProjectionView, in order. +#define XR_LIST_STRUCT_XrCompositionLayerProjectionView(_) \ + _(type) \ + _(next) \ + _(pose) \ + _(fov) \ + _(subImage) \ + +/// Calls your macro with the name of each member of XrCompositionLayerProjection, in order. +#define XR_LIST_STRUCT_XrCompositionLayerProjection(_) \ + _(type) \ + _(next) \ + _(layerFlags) \ + _(space) \ + _(viewCount) \ + _(views) \ + +/// Calls your macro with the name of each member of XrCompositionLayerQuad, in order. +#define XR_LIST_STRUCT_XrCompositionLayerQuad(_) \ + _(type) \ + _(next) \ + _(layerFlags) \ + _(space) \ + _(eyeVisibility) \ + _(subImage) \ + _(pose) \ + _(size) \ + +/// Calls your macro with the name of each member of XrEventDataBaseHeader, in order. +#define XR_LIST_STRUCT_XrEventDataBaseHeader(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrEventDataEventsLost, in order. +#define XR_LIST_STRUCT_XrEventDataEventsLost(_) \ + _(type) \ + _(next) \ + _(lostEventCount) \ + +/// Calls your macro with the name of each member of XrEventDataInstanceLossPending, in order. +#define XR_LIST_STRUCT_XrEventDataInstanceLossPending(_) \ + _(type) \ + _(next) \ + _(lossTime) \ + +/// Calls your macro with the name of each member of XrEventDataSessionStateChanged, in order. +#define XR_LIST_STRUCT_XrEventDataSessionStateChanged(_) \ + _(type) \ + _(next) \ + _(session) \ + _(state) \ + _(time) \ + +/// Calls your macro with the name of each member of XrEventDataReferenceSpaceChangePending, in order. +#define XR_LIST_STRUCT_XrEventDataReferenceSpaceChangePending(_) \ + _(type) \ + _(next) \ + _(session) \ + _(referenceSpaceType) \ + _(changeTime) \ + _(poseValid) \ + _(poseInPreviousSpace) \ + +/// Calls your macro with the name of each member of XrEventDataInteractionProfileChanged, in order. +#define XR_LIST_STRUCT_XrEventDataInteractionProfileChanged(_) \ + _(type) \ + _(next) \ + _(session) \ + +/// Calls your macro with the name of each member of XrHapticVibration, in order. +#define XR_LIST_STRUCT_XrHapticVibration(_) \ + _(type) \ + _(next) \ + _(duration) \ + _(frequency) \ + _(amplitude) \ + +/// Calls your macro with the name of each member of XrOffset2Df, in order. +#define XR_LIST_STRUCT_XrOffset2Df(_) \ + _(x) \ + _(y) \ + +/// Calls your macro with the name of each member of XrRect2Df, in order. +#define XR_LIST_STRUCT_XrRect2Df(_) \ + _(offset) \ + _(extent) \ + +/// Calls your macro with the name of each member of XrVector4f, in order. +#define XR_LIST_STRUCT_XrVector4f(_) \ + _(x) \ + _(y) \ + _(z) \ + _(w) \ + +/// Calls your macro with the name of each member of XrColor4f, in order. +#define XR_LIST_STRUCT_XrColor4f(_) \ + _(r) \ + _(g) \ + _(b) \ + _(a) \ + +/// Calls your macro with the name of each member of XrApiLayerNextInfo, in order. +#define XR_LIST_STRUCT_XrApiLayerNextInfo(_) \ + _(structType) \ + _(structVersion) \ + _(structSize) \ + _(layerName) \ + _(nextGetInstanceProcAddr) \ + _(nextCreateApiLayerInstance) \ + _(next) \ + +/// Calls your macro with the name of each member of XrApiLayerCreateInfo, in order. +#define XR_LIST_STRUCT_XrApiLayerCreateInfo(_) \ + _(structType) \ + _(structVersion) \ + _(structSize) \ + _(loaderInstance) \ + _(settings_file_location) \ + _(nextInfo) \ + +/// Calls your macro with the name of each member of XrNegotiateApiLayerRequest, in order. +#define XR_LIST_STRUCT_XrNegotiateApiLayerRequest(_) \ + _(structType) \ + _(structVersion) \ + _(structSize) \ + _(layerInterfaceVersion) \ + _(layerApiVersion) \ + _(getInstanceProcAddr) \ + _(createApiLayerInstance) \ + +/// Calls your macro with the name of each member of XrNegotiateLoaderInfo, in order. +#define XR_LIST_STRUCT_XrNegotiateLoaderInfo(_) \ + _(structType) \ + _(structVersion) \ + _(structSize) \ + _(minInterfaceVersion) \ + _(maxInterfaceVersion) \ + _(minApiVersion) \ + _(maxApiVersion) \ + +/// Calls your macro with the name of each member of XrNegotiateRuntimeRequest, in order. +#define XR_LIST_STRUCT_XrNegotiateRuntimeRequest(_) \ + _(structType) \ + _(structVersion) \ + _(structSize) \ + _(runtimeInterfaceVersion) \ + _(runtimeApiVersion) \ + _(getInstanceProcAddr) \ + +/// Calls your macro with the name of each member of XrColor3f, in order. +#define XR_LIST_STRUCT_XrColor3f(_) \ + _(r) \ + _(g) \ + _(b) \ + +/// Calls your macro with the name of each member of XrExtent3Df, in order. +#define XR_LIST_STRUCT_XrExtent3Df(_) \ + _(width) \ + _(height) \ + _(depth) \ + +/// Calls your macro with the name of each member of XrSpheref, in order. +#define XR_LIST_STRUCT_XrSpheref(_) \ + _(center) \ + _(radius) \ + +/// Calls your macro with the name of each member of XrBoxf, in order. +#define XR_LIST_STRUCT_XrBoxf(_) \ + _(center) \ + _(extents) \ + +/// Calls your macro with the name of each member of XrFrustumf, in order. +#define XR_LIST_STRUCT_XrFrustumf(_) \ + _(pose) \ + _(fov) \ + _(nearZ) \ + _(farZ) \ + +/// Calls your macro with the name of each member of XrUuid, in order. +#define XR_LIST_STRUCT_XrUuid(_) \ + _(data) \ + +/// Calls your macro with the name of each member of XrSpacesLocateInfo, in order. +#define XR_LIST_STRUCT_XrSpacesLocateInfo(_) \ + _(type) \ + _(next) \ + _(baseSpace) \ + _(time) \ + _(spaceCount) \ + _(spaces) \ + +/// Calls your macro with the name of each member of XrSpaceLocationData, in order. +#define XR_LIST_STRUCT_XrSpaceLocationData(_) \ + _(locationFlags) \ + _(pose) \ + +/// Calls your macro with the name of each member of XrSpaceLocations, in order. +#define XR_LIST_STRUCT_XrSpaceLocations(_) \ + _(type) \ + _(next) \ + _(locationCount) \ + _(locations) \ + +/// Calls your macro with the name of each member of XrSpaceVelocityData, in order. +#define XR_LIST_STRUCT_XrSpaceVelocityData(_) \ + _(velocityFlags) \ + _(linearVelocity) \ + _(angularVelocity) \ + +/// Calls your macro with the name of each member of XrSpaceVelocities, in order. +#define XR_LIST_STRUCT_XrSpaceVelocities(_) \ + _(type) \ + _(next) \ + _(velocityCount) \ + _(velocities) \ + +/// Calls your macro with the name of each member of XrCompositionLayerCubeKHR, in order. +#define XR_LIST_STRUCT_XrCompositionLayerCubeKHR(_) \ + _(type) \ + _(next) \ + _(layerFlags) \ + _(space) \ + _(eyeVisibility) \ + _(swapchain) \ + _(imageArrayIndex) \ + _(orientation) \ + +/// Calls your macro with the name of each member of XrInstanceCreateInfoAndroidKHR, in order. +#define XR_LIST_STRUCT_XrInstanceCreateInfoAndroidKHR(_) \ + _(type) \ + _(next) \ + _(applicationVM) \ + _(applicationActivity) \ + +/// Calls your macro with the name of each member of XrCompositionLayerDepthInfoKHR, in order. +#define XR_LIST_STRUCT_XrCompositionLayerDepthInfoKHR(_) \ + _(type) \ + _(next) \ + _(subImage) \ + _(minDepth) \ + _(maxDepth) \ + _(nearZ) \ + _(farZ) \ + +/// Calls your macro with the name of each member of XrVulkanSwapchainFormatListCreateInfoKHR, in order. +#define XR_LIST_STRUCT_XrVulkanSwapchainFormatListCreateInfoKHR(_) \ + _(type) \ + _(next) \ + _(viewFormatCount) \ + _(viewFormats) \ + +/// Calls your macro with the name of each member of XrCompositionLayerCylinderKHR, in order. +#define XR_LIST_STRUCT_XrCompositionLayerCylinderKHR(_) \ + _(type) \ + _(next) \ + _(layerFlags) \ + _(space) \ + _(eyeVisibility) \ + _(subImage) \ + _(pose) \ + _(radius) \ + _(centralAngle) \ + _(aspectRatio) \ + +/// Calls your macro with the name of each member of XrCompositionLayerEquirectKHR, in order. +#define XR_LIST_STRUCT_XrCompositionLayerEquirectKHR(_) \ + _(type) \ + _(next) \ + _(layerFlags) \ + _(space) \ + _(eyeVisibility) \ + _(subImage) \ + _(pose) \ + _(radius) \ + _(scale) \ + _(bias) \ + +/// Calls your macro with the name of each member of XrGraphicsBindingOpenGLWin32KHR, in order. +#define XR_LIST_STRUCT_XrGraphicsBindingOpenGLWin32KHR(_) \ + _(type) \ + _(next) \ + _(hDC) \ + _(hGLRC) \ + +/// Calls your macro with the name of each member of XrGraphicsBindingOpenGLXlibKHR, in order. +#define XR_LIST_STRUCT_XrGraphicsBindingOpenGLXlibKHR(_) \ + _(type) \ + _(next) \ + _(xDisplay) \ + _(visualid) \ + _(glxFBConfig) \ + _(glxDrawable) \ + _(glxContext) \ + +/// Calls your macro with the name of each member of XrGraphicsBindingOpenGLXcbKHR, in order. +#define XR_LIST_STRUCT_XrGraphicsBindingOpenGLXcbKHR(_) \ + _(type) \ + _(next) \ + _(connection) \ + _(screenNumber) \ + _(fbconfigid) \ + _(visualid) \ + _(glxDrawable) \ + _(glxContext) \ + +/// Calls your macro with the name of each member of XrGraphicsBindingOpenGLWaylandKHR, in order. +#define XR_LIST_STRUCT_XrGraphicsBindingOpenGLWaylandKHR(_) \ + _(type) \ + _(next) \ + _(display) \ + +/// Calls your macro with the name of each member of XrSwapchainImageOpenGLKHR, in order. +#define XR_LIST_STRUCT_XrSwapchainImageOpenGLKHR(_) \ + _(type) \ + _(next) \ + _(image) \ + +/// Calls your macro with the name of each member of XrGraphicsRequirementsOpenGLKHR, in order. +#define XR_LIST_STRUCT_XrGraphicsRequirementsOpenGLKHR(_) \ + _(type) \ + _(next) \ + _(minApiVersionSupported) \ + _(maxApiVersionSupported) \ + +/// Calls your macro with the name of each member of XrGraphicsBindingOpenGLESAndroidKHR, in order. +#define XR_LIST_STRUCT_XrGraphicsBindingOpenGLESAndroidKHR(_) \ + _(type) \ + _(next) \ + _(display) \ + _(config) \ + _(context) \ + +/// Calls your macro with the name of each member of XrSwapchainImageOpenGLESKHR, in order. +#define XR_LIST_STRUCT_XrSwapchainImageOpenGLESKHR(_) \ + _(type) \ + _(next) \ + _(image) \ + +/// Calls your macro with the name of each member of XrGraphicsRequirementsOpenGLESKHR, in order. +#define XR_LIST_STRUCT_XrGraphicsRequirementsOpenGLESKHR(_) \ + _(type) \ + _(next) \ + _(minApiVersionSupported) \ + _(maxApiVersionSupported) \ + +/// Calls your macro with the name of each member of XrGraphicsBindingVulkanKHR, in order. +#define XR_LIST_STRUCT_XrGraphicsBindingVulkanKHR(_) \ + _(type) \ + _(next) \ + _(instance) \ + _(physicalDevice) \ + _(device) \ + _(queueFamilyIndex) \ + _(queueIndex) \ + +/// Calls your macro with the name of each member of XrSwapchainImageVulkanKHR, in order. +#define XR_LIST_STRUCT_XrSwapchainImageVulkanKHR(_) \ + _(type) \ + _(next) \ + _(image) \ + +/// Calls your macro with the name of each member of XrGraphicsRequirementsVulkanKHR, in order. +#define XR_LIST_STRUCT_XrGraphicsRequirementsVulkanKHR(_) \ + _(type) \ + _(next) \ + _(minApiVersionSupported) \ + _(maxApiVersionSupported) \ + +/// Calls your macro with the name of each member of XrGraphicsBindingD3D11KHR, in order. +#define XR_LIST_STRUCT_XrGraphicsBindingD3D11KHR(_) \ + _(type) \ + _(next) \ + _(device) \ + +/// Calls your macro with the name of each member of XrSwapchainImageD3D11KHR, in order. +#define XR_LIST_STRUCT_XrSwapchainImageD3D11KHR(_) \ + _(type) \ + _(next) \ + _(texture) \ + +/// Calls your macro with the name of each member of XrGraphicsRequirementsD3D11KHR, in order. +#define XR_LIST_STRUCT_XrGraphicsRequirementsD3D11KHR(_) \ + _(type) \ + _(next) \ + _(adapterLuid) \ + _(minFeatureLevel) \ + +/// Calls your macro with the name of each member of XrGraphicsBindingD3D12KHR, in order. +#define XR_LIST_STRUCT_XrGraphicsBindingD3D12KHR(_) \ + _(type) \ + _(next) \ + _(device) \ + _(queue) \ + +/// Calls your macro with the name of each member of XrSwapchainImageD3D12KHR, in order. +#define XR_LIST_STRUCT_XrSwapchainImageD3D12KHR(_) \ + _(type) \ + _(next) \ + _(texture) \ + +/// Calls your macro with the name of each member of XrGraphicsRequirementsD3D12KHR, in order. +#define XR_LIST_STRUCT_XrGraphicsRequirementsD3D12KHR(_) \ + _(type) \ + _(next) \ + _(adapterLuid) \ + _(minFeatureLevel) \ + +/// Calls your macro with the name of each member of XrGraphicsBindingMetalKHR, in order. +#define XR_LIST_STRUCT_XrGraphicsBindingMetalKHR(_) \ + _(type) \ + _(next) \ + _(commandQueue) \ + +/// Calls your macro with the name of each member of XrSwapchainImageMetalKHR, in order. +#define XR_LIST_STRUCT_XrSwapchainImageMetalKHR(_) \ + _(type) \ + _(next) \ + _(texture) \ + +/// Calls your macro with the name of each member of XrGraphicsRequirementsMetalKHR, in order. +#define XR_LIST_STRUCT_XrGraphicsRequirementsMetalKHR(_) \ + _(type) \ + _(next) \ + _(metalDevice) \ + +/// Calls your macro with the name of each member of XrVisibilityMaskKHR, in order. +#define XR_LIST_STRUCT_XrVisibilityMaskKHR(_) \ + _(type) \ + _(next) \ + _(vertexCapacityInput) \ + _(vertexCountOutput) \ + _(vertices) \ + _(indexCapacityInput) \ + _(indexCountOutput) \ + _(indices) \ + +/// Calls your macro with the name of each member of XrEventDataVisibilityMaskChangedKHR, in order. +#define XR_LIST_STRUCT_XrEventDataVisibilityMaskChangedKHR(_) \ + _(type) \ + _(next) \ + _(session) \ + _(viewConfigurationType) \ + _(viewIndex) \ + +/// Calls your macro with the name of each member of XrCompositionLayerColorScaleBiasKHR, in order. +#define XR_LIST_STRUCT_XrCompositionLayerColorScaleBiasKHR(_) \ + _(type) \ + _(next) \ + _(colorScale) \ + _(colorBias) \ + +/// Calls your macro with the name of each member of XrLoaderInitInfoBaseHeaderKHR, in order. +#define XR_LIST_STRUCT_XrLoaderInitInfoBaseHeaderKHR(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrLoaderInitInfoAndroidKHR, in order. +#define XR_LIST_STRUCT_XrLoaderInitInfoAndroidKHR(_) \ + _(type) \ + _(next) \ + _(applicationVM) \ + _(applicationContext) \ + +/// Calls your macro with the name of each member of XrVulkanInstanceCreateInfoKHR, in order. +#define XR_LIST_STRUCT_XrVulkanInstanceCreateInfoKHR(_) \ + _(type) \ + _(next) \ + _(systemId) \ + _(createFlags) \ + _(pfnGetInstanceProcAddr) \ + _(vulkanCreateInfo) \ + _(vulkanAllocator) \ + +/// Calls your macro with the name of each member of XrVulkanDeviceCreateInfoKHR, in order. +#define XR_LIST_STRUCT_XrVulkanDeviceCreateInfoKHR(_) \ + _(type) \ + _(next) \ + _(systemId) \ + _(createFlags) \ + _(pfnGetInstanceProcAddr) \ + _(vulkanPhysicalDevice) \ + _(vulkanCreateInfo) \ + _(vulkanAllocator) \ + +/// Calls your macro with the name of each member of XrVulkanGraphicsDeviceGetInfoKHR, in order. +#define XR_LIST_STRUCT_XrVulkanGraphicsDeviceGetInfoKHR(_) \ + _(type) \ + _(next) \ + _(systemId) \ + _(vulkanInstance) \ + +/// Calls your macro with the name of each member of XrCompositionLayerEquirect2KHR, in order. +#define XR_LIST_STRUCT_XrCompositionLayerEquirect2KHR(_) \ + _(type) \ + _(next) \ + _(layerFlags) \ + _(space) \ + _(eyeVisibility) \ + _(subImage) \ + _(pose) \ + _(radius) \ + _(centralHorizontalAngle) \ + _(upperVerticalAngle) \ + _(lowerVerticalAngle) \ + +/// Calls your macro with the name of each member of XrBindingModificationBaseHeaderKHR, in order. +#define XR_LIST_STRUCT_XrBindingModificationBaseHeaderKHR(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrBindingModificationsKHR, in order. +#define XR_LIST_STRUCT_XrBindingModificationsKHR(_) \ + _(type) \ + _(next) \ + _(bindingModificationCount) \ + _(bindingModifications) \ + +/// Calls your macro with the name of each member of XrEventDataPerfSettingsEXT, in order. +#define XR_LIST_STRUCT_XrEventDataPerfSettingsEXT(_) \ + _(type) \ + _(next) \ + _(domain) \ + _(subDomain) \ + _(fromLevel) \ + _(toLevel) \ + +/// Calls your macro with the name of each member of XrDebugUtilsObjectNameInfoEXT, in order. +#define XR_LIST_STRUCT_XrDebugUtilsObjectNameInfoEXT(_) \ + _(type) \ + _(next) \ + _(objectType) \ + _(objectHandle) \ + _(objectName) \ + +/// Calls your macro with the name of each member of XrDebugUtilsLabelEXT, in order. +#define XR_LIST_STRUCT_XrDebugUtilsLabelEXT(_) \ + _(type) \ + _(next) \ + _(labelName) \ + +/// Calls your macro with the name of each member of XrDebugUtilsMessengerCallbackDataEXT, in order. +#define XR_LIST_STRUCT_XrDebugUtilsMessengerCallbackDataEXT(_) \ + _(type) \ + _(next) \ + _(messageId) \ + _(functionName) \ + _(message) \ + _(objectCount) \ + _(objects) \ + _(sessionLabelCount) \ + _(sessionLabels) \ + +/// Calls your macro with the name of each member of XrDebugUtilsMessengerCreateInfoEXT, in order. +#define XR_LIST_STRUCT_XrDebugUtilsMessengerCreateInfoEXT(_) \ + _(type) \ + _(next) \ + _(messageSeverities) \ + _(messageTypes) \ + _(userCallback) \ + _(userData) \ + +/// Calls your macro with the name of each member of XrSystemEyeGazeInteractionPropertiesEXT, in order. +#define XR_LIST_STRUCT_XrSystemEyeGazeInteractionPropertiesEXT(_) \ + _(type) \ + _(next) \ + _(supportsEyeGazeInteraction) \ + +/// Calls your macro with the name of each member of XrEyeGazeSampleTimeEXT, in order. +#define XR_LIST_STRUCT_XrEyeGazeSampleTimeEXT(_) \ + _(type) \ + _(next) \ + _(time) \ + +/// Calls your macro with the name of each member of XrSessionCreateInfoOverlayEXTX, in order. +#define XR_LIST_STRUCT_XrSessionCreateInfoOverlayEXTX(_) \ + _(type) \ + _(next) \ + _(createFlags) \ + _(sessionLayersPlacement) \ + +/// Calls your macro with the name of each member of XrEventDataMainSessionVisibilityChangedEXTX, in order. +#define XR_LIST_STRUCT_XrEventDataMainSessionVisibilityChangedEXTX(_) \ + _(type) \ + _(next) \ + _(visible) \ + _(flags) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorCreateInfoMSFT, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorCreateInfoMSFT(_) \ + _(type) \ + _(next) \ + _(space) \ + _(pose) \ + _(time) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorSpaceCreateInfoMSFT, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorSpaceCreateInfoMSFT(_) \ + _(type) \ + _(next) \ + _(anchor) \ + _(poseInAnchorSpace) \ + +/// Calls your macro with the name of each member of XrCompositionLayerImageLayoutFB, in order. +#define XR_LIST_STRUCT_XrCompositionLayerImageLayoutFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + +/// Calls your macro with the name of each member of XrCompositionLayerAlphaBlendFB, in order. +#define XR_LIST_STRUCT_XrCompositionLayerAlphaBlendFB(_) \ + _(type) \ + _(next) \ + _(srcFactorColor) \ + _(dstFactorColor) \ + _(srcFactorAlpha) \ + _(dstFactorAlpha) \ + +/// Calls your macro with the name of each member of XrViewConfigurationDepthRangeEXT, in order. +#define XR_LIST_STRUCT_XrViewConfigurationDepthRangeEXT(_) \ + _(type) \ + _(next) \ + _(recommendedNearZ) \ + _(minNearZ) \ + _(recommendedFarZ) \ + _(maxFarZ) \ + +/// Calls your macro with the name of each member of XrGraphicsBindingEGLMNDX, in order. +#define XR_LIST_STRUCT_XrGraphicsBindingEGLMNDX(_) \ + _(type) \ + _(next) \ + _(getProcAddress) \ + _(display) \ + _(config) \ + _(context) \ + +/// Calls your macro with the name of each member of XrSpatialGraphNodeSpaceCreateInfoMSFT, in order. +#define XR_LIST_STRUCT_XrSpatialGraphNodeSpaceCreateInfoMSFT(_) \ + _(type) \ + _(next) \ + _(nodeType) \ + _(nodeId) \ + _(pose) \ + +/// Calls your macro with the name of each member of XrSpatialGraphStaticNodeBindingCreateInfoMSFT, in order. +#define XR_LIST_STRUCT_XrSpatialGraphStaticNodeBindingCreateInfoMSFT(_) \ + _(type) \ + _(next) \ + _(space) \ + _(poseInSpace) \ + _(time) \ + +/// Calls your macro with the name of each member of XrSpatialGraphNodeBindingPropertiesGetInfoMSFT, in order. +#define XR_LIST_STRUCT_XrSpatialGraphNodeBindingPropertiesGetInfoMSFT(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSpatialGraphNodeBindingPropertiesMSFT, in order. +#define XR_LIST_STRUCT_XrSpatialGraphNodeBindingPropertiesMSFT(_) \ + _(type) \ + _(next) \ + _(nodeId) \ + _(poseInNodeSpace) \ + +/// Calls your macro with the name of each member of XrSystemHandTrackingPropertiesEXT, in order. +#define XR_LIST_STRUCT_XrSystemHandTrackingPropertiesEXT(_) \ + _(type) \ + _(next) \ + _(supportsHandTracking) \ + +/// Calls your macro with the name of each member of XrHandTrackerCreateInfoEXT, in order. +#define XR_LIST_STRUCT_XrHandTrackerCreateInfoEXT(_) \ + _(type) \ + _(next) \ + _(hand) \ + _(handJointSet) \ + +/// Calls your macro with the name of each member of XrHandJointsLocateInfoEXT, in order. +#define XR_LIST_STRUCT_XrHandJointsLocateInfoEXT(_) \ + _(type) \ + _(next) \ + _(baseSpace) \ + _(time) \ + +/// Calls your macro with the name of each member of XrHandJointLocationEXT, in order. +#define XR_LIST_STRUCT_XrHandJointLocationEXT(_) \ + _(locationFlags) \ + _(pose) \ + _(radius) \ + +/// Calls your macro with the name of each member of XrHandJointVelocityEXT, in order. +#define XR_LIST_STRUCT_XrHandJointVelocityEXT(_) \ + _(velocityFlags) \ + _(linearVelocity) \ + _(angularVelocity) \ + +/// Calls your macro with the name of each member of XrHandJointLocationsEXT, in order. +#define XR_LIST_STRUCT_XrHandJointLocationsEXT(_) \ + _(type) \ + _(next) \ + _(isActive) \ + _(jointCount) \ + _(jointLocations) \ + +/// Calls your macro with the name of each member of XrHandJointVelocitiesEXT, in order. +#define XR_LIST_STRUCT_XrHandJointVelocitiesEXT(_) \ + _(type) \ + _(next) \ + _(jointCount) \ + _(jointVelocities) \ + +/// Calls your macro with the name of each member of XrSystemHandTrackingMeshPropertiesMSFT, in order. +#define XR_LIST_STRUCT_XrSystemHandTrackingMeshPropertiesMSFT(_) \ + _(type) \ + _(next) \ + _(supportsHandTrackingMesh) \ + _(maxHandMeshIndexCount) \ + _(maxHandMeshVertexCount) \ + +/// Calls your macro with the name of each member of XrHandMeshSpaceCreateInfoMSFT, in order. +#define XR_LIST_STRUCT_XrHandMeshSpaceCreateInfoMSFT(_) \ + _(type) \ + _(next) \ + _(handPoseType) \ + _(poseInHandMeshSpace) \ + +/// Calls your macro with the name of each member of XrHandMeshUpdateInfoMSFT, in order. +#define XR_LIST_STRUCT_XrHandMeshUpdateInfoMSFT(_) \ + _(type) \ + _(next) \ + _(time) \ + _(handPoseType) \ + +/// Calls your macro with the name of each member of XrHandMeshIndexBufferMSFT, in order. +#define XR_LIST_STRUCT_XrHandMeshIndexBufferMSFT(_) \ + _(indexBufferKey) \ + _(indexCapacityInput) \ + _(indexCountOutput) \ + _(indices) \ + +/// Calls your macro with the name of each member of XrHandMeshVertexMSFT, in order. +#define XR_LIST_STRUCT_XrHandMeshVertexMSFT(_) \ + _(position) \ + _(normal) \ + +/// Calls your macro with the name of each member of XrHandMeshVertexBufferMSFT, in order. +#define XR_LIST_STRUCT_XrHandMeshVertexBufferMSFT(_) \ + _(vertexUpdateTime) \ + _(vertexCapacityInput) \ + _(vertexCountOutput) \ + _(vertices) \ + +/// Calls your macro with the name of each member of XrHandMeshMSFT, in order. +#define XR_LIST_STRUCT_XrHandMeshMSFT(_) \ + _(type) \ + _(next) \ + _(isActive) \ + _(indexBufferChanged) \ + _(vertexBufferChanged) \ + _(indexBuffer) \ + _(vertexBuffer) \ + +/// Calls your macro with the name of each member of XrHandPoseTypeInfoMSFT, in order. +#define XR_LIST_STRUCT_XrHandPoseTypeInfoMSFT(_) \ + _(type) \ + _(next) \ + _(handPoseType) \ + +/// Calls your macro with the name of each member of XrSecondaryViewConfigurationSessionBeginInfoMSFT, in order. +#define XR_LIST_STRUCT_XrSecondaryViewConfigurationSessionBeginInfoMSFT(_) \ + _(type) \ + _(next) \ + _(viewConfigurationCount) \ + _(enabledViewConfigurationTypes) \ + +/// Calls your macro with the name of each member of XrSecondaryViewConfigurationStateMSFT, in order. +#define XR_LIST_STRUCT_XrSecondaryViewConfigurationStateMSFT(_) \ + _(type) \ + _(next) \ + _(viewConfigurationType) \ + _(active) \ + +/// Calls your macro with the name of each member of XrSecondaryViewConfigurationFrameStateMSFT, in order. +#define XR_LIST_STRUCT_XrSecondaryViewConfigurationFrameStateMSFT(_) \ + _(type) \ + _(next) \ + _(viewConfigurationCount) \ + _(viewConfigurationStates) \ + +/// Calls your macro with the name of each member of XrSecondaryViewConfigurationLayerInfoMSFT, in order. +#define XR_LIST_STRUCT_XrSecondaryViewConfigurationLayerInfoMSFT(_) \ + _(type) \ + _(next) \ + _(viewConfigurationType) \ + _(environmentBlendMode) \ + _(layerCount) \ + _(layers) \ + +/// Calls your macro with the name of each member of XrSecondaryViewConfigurationFrameEndInfoMSFT, in order. +#define XR_LIST_STRUCT_XrSecondaryViewConfigurationFrameEndInfoMSFT(_) \ + _(type) \ + _(next) \ + _(viewConfigurationCount) \ + _(viewConfigurationLayersInfo) \ + +/// Calls your macro with the name of each member of XrSecondaryViewConfigurationSwapchainCreateInfoMSFT, in order. +#define XR_LIST_STRUCT_XrSecondaryViewConfigurationSwapchainCreateInfoMSFT(_) \ + _(type) \ + _(next) \ + _(viewConfigurationType) \ + +/// Calls your macro with the name of each member of XrControllerModelKeyStateMSFT, in order. +#define XR_LIST_STRUCT_XrControllerModelKeyStateMSFT(_) \ + _(type) \ + _(next) \ + _(modelKey) \ + +/// Calls your macro with the name of each member of XrControllerModelNodePropertiesMSFT, in order. +#define XR_LIST_STRUCT_XrControllerModelNodePropertiesMSFT(_) \ + _(type) \ + _(next) \ + _(parentNodeName) \ + _(nodeName) \ + +/// Calls your macro with the name of each member of XrControllerModelPropertiesMSFT, in order. +#define XR_LIST_STRUCT_XrControllerModelPropertiesMSFT(_) \ + _(type) \ + _(next) \ + _(nodeCapacityInput) \ + _(nodeCountOutput) \ + _(nodeProperties) \ + +/// Calls your macro with the name of each member of XrControllerModelNodeStateMSFT, in order. +#define XR_LIST_STRUCT_XrControllerModelNodeStateMSFT(_) \ + _(type) \ + _(next) \ + _(nodePose) \ + +/// Calls your macro with the name of each member of XrControllerModelStateMSFT, in order. +#define XR_LIST_STRUCT_XrControllerModelStateMSFT(_) \ + _(type) \ + _(next) \ + _(nodeCapacityInput) \ + _(nodeCountOutput) \ + _(nodeStates) \ + +/// Calls your macro with the name of each member of XrViewConfigurationViewFovEPIC, in order. +#define XR_LIST_STRUCT_XrViewConfigurationViewFovEPIC(_) \ + _(type) \ + _(next) \ + _(recommendedFov) \ + _(maxMutableFov) \ + +/// Calls your macro with the name of each member of XrHolographicWindowAttachmentMSFT, in order. +#define XR_LIST_STRUCT_XrHolographicWindowAttachmentMSFT(_) \ + _(type) \ + _(next) \ + _(holographicSpace) \ + _(coreWindow) \ + +/// Calls your macro with the name of each member of XrCompositionLayerReprojectionInfoMSFT, in order. +#define XR_LIST_STRUCT_XrCompositionLayerReprojectionInfoMSFT(_) \ + _(type) \ + _(next) \ + _(reprojectionMode) \ + +/// Calls your macro with the name of each member of XrCompositionLayerReprojectionPlaneOverrideMSFT, in order. +#define XR_LIST_STRUCT_XrCompositionLayerReprojectionPlaneOverrideMSFT(_) \ + _(type) \ + _(next) \ + _(position) \ + _(normal) \ + _(velocity) \ + +/// Calls your macro with the name of each member of XrAndroidSurfaceSwapchainCreateInfoFB, in order. +#define XR_LIST_STRUCT_XrAndroidSurfaceSwapchainCreateInfoFB(_) \ + _(type) \ + _(next) \ + _(createFlags) \ + +/// Calls your macro with the name of each member of XrSwapchainStateBaseHeaderFB, in order. +#define XR_LIST_STRUCT_XrSwapchainStateBaseHeaderFB(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrCompositionLayerSecureContentFB, in order. +#define XR_LIST_STRUCT_XrCompositionLayerSecureContentFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + +/// Calls your macro with the name of each member of XrBodyJointLocationFB, in order. +#define XR_LIST_STRUCT_XrBodyJointLocationFB(_) \ + _(locationFlags) \ + _(pose) \ + +/// Calls your macro with the name of each member of XrSystemBodyTrackingPropertiesFB, in order. +#define XR_LIST_STRUCT_XrSystemBodyTrackingPropertiesFB(_) \ + _(type) \ + _(next) \ + _(supportsBodyTracking) \ + +/// Calls your macro with the name of each member of XrBodyTrackerCreateInfoFB, in order. +#define XR_LIST_STRUCT_XrBodyTrackerCreateInfoFB(_) \ + _(type) \ + _(next) \ + _(bodyJointSet) \ + +/// Calls your macro with the name of each member of XrBodySkeletonJointFB, in order. +#define XR_LIST_STRUCT_XrBodySkeletonJointFB(_) \ + _(joint) \ + _(parentJoint) \ + _(pose) \ + +/// Calls your macro with the name of each member of XrBodySkeletonFB, in order. +#define XR_LIST_STRUCT_XrBodySkeletonFB(_) \ + _(type) \ + _(next) \ + _(jointCount) \ + _(joints) \ + +/// Calls your macro with the name of each member of XrBodyJointsLocateInfoFB, in order. +#define XR_LIST_STRUCT_XrBodyJointsLocateInfoFB(_) \ + _(type) \ + _(next) \ + _(baseSpace) \ + _(time) \ + +/// Calls your macro with the name of each member of XrBodyJointLocationsFB, in order. +#define XR_LIST_STRUCT_XrBodyJointLocationsFB(_) \ + _(type) \ + _(next) \ + _(isActive) \ + _(confidence) \ + _(jointCount) \ + _(jointLocations) \ + _(skeletonChangedCount) \ + _(time) \ + +/// Calls your macro with the name of each member of XrInteractionProfileDpadBindingEXT, in order. +#define XR_LIST_STRUCT_XrInteractionProfileDpadBindingEXT(_) \ + _(type) \ + _(next) \ + _(binding) \ + _(actionSet) \ + _(forceThreshold) \ + _(forceThresholdReleased) \ + _(centerRegion) \ + _(wedgeAngle) \ + _(isSticky) \ + _(onHaptic) \ + _(offHaptic) \ + +/// Calls your macro with the name of each member of XrInteractionProfileAnalogThresholdVALVE, in order. +#define XR_LIST_STRUCT_XrInteractionProfileAnalogThresholdVALVE(_) \ + _(type) \ + _(next) \ + _(action) \ + _(binding) \ + _(onThreshold) \ + _(offThreshold) \ + _(onHaptic) \ + _(offHaptic) \ + +/// Calls your macro with the name of each member of XrHandJointsMotionRangeInfoEXT, in order. +#define XR_LIST_STRUCT_XrHandJointsMotionRangeInfoEXT(_) \ + _(type) \ + _(next) \ + _(handJointsMotionRange) \ + +/// Calls your macro with the name of each member of XrUuidMSFT, in order. +#define XR_LIST_STRUCT_XrUuidMSFT(_) \ + _(bytes) \ + +/// Calls your macro with the name of each member of XrSceneObserverCreateInfoMSFT, in order. +#define XR_LIST_STRUCT_XrSceneObserverCreateInfoMSFT(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSceneCreateInfoMSFT, in order. +#define XR_LIST_STRUCT_XrSceneCreateInfoMSFT(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSceneSphereBoundMSFT, in order. +#define XR_LIST_STRUCT_XrSceneSphereBoundMSFT(_) \ + _(center) \ + _(radius) \ + +/// Calls your macro with the name of each member of XrSceneOrientedBoxBoundMSFT, in order. +#define XR_LIST_STRUCT_XrSceneOrientedBoxBoundMSFT(_) \ + _(pose) \ + _(extents) \ + +/// Calls your macro with the name of each member of XrSceneFrustumBoundMSFT, in order. +#define XR_LIST_STRUCT_XrSceneFrustumBoundMSFT(_) \ + _(pose) \ + _(fov) \ + _(farDistance) \ + +/// Calls your macro with the name of each member of XrSceneBoundsMSFT, in order. +#define XR_LIST_STRUCT_XrSceneBoundsMSFT(_) \ + _(space) \ + _(time) \ + _(sphereCount) \ + _(spheres) \ + _(boxCount) \ + _(boxes) \ + _(frustumCount) \ + _(frustums) \ + +/// Calls your macro with the name of each member of XrNewSceneComputeInfoMSFT, in order. +#define XR_LIST_STRUCT_XrNewSceneComputeInfoMSFT(_) \ + _(type) \ + _(next) \ + _(requestedFeatureCount) \ + _(requestedFeatures) \ + _(consistency) \ + _(bounds) \ + +/// Calls your macro with the name of each member of XrVisualMeshComputeLodInfoMSFT, in order. +#define XR_LIST_STRUCT_XrVisualMeshComputeLodInfoMSFT(_) \ + _(type) \ + _(next) \ + _(lod) \ + +/// Calls your macro with the name of each member of XrSceneComponentMSFT, in order. +#define XR_LIST_STRUCT_XrSceneComponentMSFT(_) \ + _(componentType) \ + _(id) \ + _(parentId) \ + _(updateTime) \ + +/// Calls your macro with the name of each member of XrSceneComponentsMSFT, in order. +#define XR_LIST_STRUCT_XrSceneComponentsMSFT(_) \ + _(type) \ + _(next) \ + _(componentCapacityInput) \ + _(componentCountOutput) \ + _(components) \ + +/// Calls your macro with the name of each member of XrSceneComponentsGetInfoMSFT, in order. +#define XR_LIST_STRUCT_XrSceneComponentsGetInfoMSFT(_) \ + _(type) \ + _(next) \ + _(componentType) \ + +/// Calls your macro with the name of each member of XrSceneComponentLocationMSFT, in order. +#define XR_LIST_STRUCT_XrSceneComponentLocationMSFT(_) \ + _(flags) \ + _(pose) \ + +/// Calls your macro with the name of each member of XrSceneComponentLocationsMSFT, in order. +#define XR_LIST_STRUCT_XrSceneComponentLocationsMSFT(_) \ + _(type) \ + _(next) \ + _(locationCount) \ + _(locations) \ + +/// Calls your macro with the name of each member of XrSceneComponentsLocateInfoMSFT, in order. +#define XR_LIST_STRUCT_XrSceneComponentsLocateInfoMSFT(_) \ + _(type) \ + _(next) \ + _(baseSpace) \ + _(time) \ + _(componentIdCount) \ + _(componentIds) \ + +/// Calls your macro with the name of each member of XrSceneObjectMSFT, in order. +#define XR_LIST_STRUCT_XrSceneObjectMSFT(_) \ + _(objectType) \ + +/// Calls your macro with the name of each member of XrSceneObjectsMSFT, in order. +#define XR_LIST_STRUCT_XrSceneObjectsMSFT(_) \ + _(type) \ + _(next) \ + _(sceneObjectCount) \ + _(sceneObjects) \ + +/// Calls your macro with the name of each member of XrSceneComponentParentFilterInfoMSFT, in order. +#define XR_LIST_STRUCT_XrSceneComponentParentFilterInfoMSFT(_) \ + _(type) \ + _(next) \ + _(parentId) \ + +/// Calls your macro with the name of each member of XrSceneObjectTypesFilterInfoMSFT, in order. +#define XR_LIST_STRUCT_XrSceneObjectTypesFilterInfoMSFT(_) \ + _(type) \ + _(next) \ + _(objectTypeCount) \ + _(objectTypes) \ + +/// Calls your macro with the name of each member of XrScenePlaneMSFT, in order. +#define XR_LIST_STRUCT_XrScenePlaneMSFT(_) \ + _(alignment) \ + _(size) \ + _(meshBufferId) \ + _(supportsIndicesUint16) \ + +/// Calls your macro with the name of each member of XrScenePlanesMSFT, in order. +#define XR_LIST_STRUCT_XrScenePlanesMSFT(_) \ + _(type) \ + _(next) \ + _(scenePlaneCount) \ + _(scenePlanes) \ + +/// Calls your macro with the name of each member of XrScenePlaneAlignmentFilterInfoMSFT, in order. +#define XR_LIST_STRUCT_XrScenePlaneAlignmentFilterInfoMSFT(_) \ + _(type) \ + _(next) \ + _(alignmentCount) \ + _(alignments) \ + +/// Calls your macro with the name of each member of XrSceneMeshMSFT, in order. +#define XR_LIST_STRUCT_XrSceneMeshMSFT(_) \ + _(meshBufferId) \ + _(supportsIndicesUint16) \ + +/// Calls your macro with the name of each member of XrSceneMeshesMSFT, in order. +#define XR_LIST_STRUCT_XrSceneMeshesMSFT(_) \ + _(type) \ + _(next) \ + _(sceneMeshCount) \ + _(sceneMeshes) \ + +/// Calls your macro with the name of each member of XrSceneMeshBuffersGetInfoMSFT, in order. +#define XR_LIST_STRUCT_XrSceneMeshBuffersGetInfoMSFT(_) \ + _(type) \ + _(next) \ + _(meshBufferId) \ + +/// Calls your macro with the name of each member of XrSceneMeshBuffersMSFT, in order. +#define XR_LIST_STRUCT_XrSceneMeshBuffersMSFT(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSceneMeshVertexBufferMSFT, in order. +#define XR_LIST_STRUCT_XrSceneMeshVertexBufferMSFT(_) \ + _(type) \ + _(next) \ + _(vertexCapacityInput) \ + _(vertexCountOutput) \ + _(vertices) \ + +/// Calls your macro with the name of each member of XrSceneMeshIndicesUint32MSFT, in order. +#define XR_LIST_STRUCT_XrSceneMeshIndicesUint32MSFT(_) \ + _(type) \ + _(next) \ + _(indexCapacityInput) \ + _(indexCountOutput) \ + _(indices) \ + +/// Calls your macro with the name of each member of XrSceneMeshIndicesUint16MSFT, in order. +#define XR_LIST_STRUCT_XrSceneMeshIndicesUint16MSFT(_) \ + _(type) \ + _(next) \ + _(indexCapacityInput) \ + _(indexCountOutput) \ + _(indices) \ + +/// Calls your macro with the name of each member of XrSerializedSceneFragmentDataGetInfoMSFT, in order. +#define XR_LIST_STRUCT_XrSerializedSceneFragmentDataGetInfoMSFT(_) \ + _(type) \ + _(next) \ + _(sceneFragmentId) \ + +/// Calls your macro with the name of each member of XrDeserializeSceneFragmentMSFT, in order. +#define XR_LIST_STRUCT_XrDeserializeSceneFragmentMSFT(_) \ + _(bufferSize) \ + _(buffer) \ + +/// Calls your macro with the name of each member of XrSceneDeserializeInfoMSFT, in order. +#define XR_LIST_STRUCT_XrSceneDeserializeInfoMSFT(_) \ + _(type) \ + _(next) \ + _(fragmentCount) \ + _(fragments) \ + +/// Calls your macro with the name of each member of XrEventDataDisplayRefreshRateChangedFB, in order. +#define XR_LIST_STRUCT_XrEventDataDisplayRefreshRateChangedFB(_) \ + _(type) \ + _(next) \ + _(fromDisplayRefreshRate) \ + _(toDisplayRefreshRate) \ + +/// Calls your macro with the name of each member of XrViveTrackerPathsHTCX, in order. +#define XR_LIST_STRUCT_XrViveTrackerPathsHTCX(_) \ + _(type) \ + _(next) \ + _(persistentPath) \ + _(rolePath) \ + +/// Calls your macro with the name of each member of XrEventDataViveTrackerConnectedHTCX, in order. +#define XR_LIST_STRUCT_XrEventDataViveTrackerConnectedHTCX(_) \ + _(type) \ + _(next) \ + _(paths) \ + +/// Calls your macro with the name of each member of XrSystemFacialTrackingPropertiesHTC, in order. +#define XR_LIST_STRUCT_XrSystemFacialTrackingPropertiesHTC(_) \ + _(type) \ + _(next) \ + _(supportEyeFacialTracking) \ + _(supportLipFacialTracking) \ + +/// Calls your macro with the name of each member of XrFacialExpressionsHTC, in order. +#define XR_LIST_STRUCT_XrFacialExpressionsHTC(_) \ + _(type) \ + _(next) \ + _(isActive) \ + _(sampleTime) \ + _(expressionCount) \ + _(expressionWeightings) \ + +/// Calls your macro with the name of each member of XrFacialTrackerCreateInfoHTC, in order. +#define XR_LIST_STRUCT_XrFacialTrackerCreateInfoHTC(_) \ + _(type) \ + _(next) \ + _(facialTrackingType) \ + +/// Calls your macro with the name of each member of XrSystemColorSpacePropertiesFB, in order. +#define XR_LIST_STRUCT_XrSystemColorSpacePropertiesFB(_) \ + _(type) \ + _(next) \ + _(colorSpace) \ + +/// Calls your macro with the name of each member of XrVector4sFB, in order. +#define XR_LIST_STRUCT_XrVector4sFB(_) \ + _(x) \ + _(y) \ + _(z) \ + _(w) \ + +/// Calls your macro with the name of each member of XrHandTrackingMeshFB, in order. +#define XR_LIST_STRUCT_XrHandTrackingMeshFB(_) \ + _(type) \ + _(next) \ + _(jointCapacityInput) \ + _(jointCountOutput) \ + _(jointBindPoses) \ + _(jointRadii) \ + _(jointParents) \ + _(vertexCapacityInput) \ + _(vertexCountOutput) \ + _(vertexPositions) \ + _(vertexNormals) \ + _(vertexUVs) \ + _(vertexBlendIndices) \ + _(vertexBlendWeights) \ + _(indexCapacityInput) \ + _(indexCountOutput) \ + _(indices) \ + +/// Calls your macro with the name of each member of XrHandTrackingScaleFB, in order. +#define XR_LIST_STRUCT_XrHandTrackingScaleFB(_) \ + _(type) \ + _(next) \ + _(sensorOutput) \ + _(currentOutput) \ + _(overrideHandScale) \ + _(overrideValueInput) \ + +/// Calls your macro with the name of each member of XrHandTrackingAimStateFB, in order. +#define XR_LIST_STRUCT_XrHandTrackingAimStateFB(_) \ + _(type) \ + _(next) \ + _(status) \ + _(aimPose) \ + _(pinchStrengthIndex) \ + _(pinchStrengthMiddle) \ + _(pinchStrengthRing) \ + _(pinchStrengthLittle) \ + +/// Calls your macro with the name of each member of XrHandCapsuleFB, in order. +#define XR_LIST_STRUCT_XrHandCapsuleFB(_) \ + _(points) \ + _(radius) \ + _(joint) \ + +/// Calls your macro with the name of each member of XrHandTrackingCapsulesStateFB, in order. +#define XR_LIST_STRUCT_XrHandTrackingCapsulesStateFB(_) \ + _(type) \ + _(next) \ + _(capsules) \ + +/// Calls your macro with the name of each member of XrSystemSpatialEntityPropertiesFB, in order. +#define XR_LIST_STRUCT_XrSystemSpatialEntityPropertiesFB(_) \ + _(type) \ + _(next) \ + _(supportsSpatialEntity) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorCreateInfoFB, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorCreateInfoFB(_) \ + _(type) \ + _(next) \ + _(space) \ + _(poseInSpace) \ + _(time) \ + +/// Calls your macro with the name of each member of XrSpaceComponentStatusSetInfoFB, in order. +#define XR_LIST_STRUCT_XrSpaceComponentStatusSetInfoFB(_) \ + _(type) \ + _(next) \ + _(componentType) \ + _(enabled) \ + _(timeout) \ + +/// Calls your macro with the name of each member of XrSpaceComponentStatusFB, in order. +#define XR_LIST_STRUCT_XrSpaceComponentStatusFB(_) \ + _(type) \ + _(next) \ + _(enabled) \ + _(changePending) \ + +/// Calls your macro with the name of each member of XrEventDataSpatialAnchorCreateCompleteFB, in order. +#define XR_LIST_STRUCT_XrEventDataSpatialAnchorCreateCompleteFB(_) \ + _(type) \ + _(next) \ + _(requestId) \ + _(result) \ + _(space) \ + _(uuid) \ + +/// Calls your macro with the name of each member of XrEventDataSpaceSetStatusCompleteFB, in order. +#define XR_LIST_STRUCT_XrEventDataSpaceSetStatusCompleteFB(_) \ + _(type) \ + _(next) \ + _(requestId) \ + _(result) \ + _(space) \ + _(uuid) \ + _(componentType) \ + _(enabled) \ + +/// Calls your macro with the name of each member of XrFoveationProfileCreateInfoFB, in order. +#define XR_LIST_STRUCT_XrFoveationProfileCreateInfoFB(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSwapchainCreateInfoFoveationFB, in order. +#define XR_LIST_STRUCT_XrSwapchainCreateInfoFoveationFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + +/// Calls your macro with the name of each member of XrSwapchainStateFoveationFB, in order. +#define XR_LIST_STRUCT_XrSwapchainStateFoveationFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + _(profile) \ + +/// Calls your macro with the name of each member of XrFoveationLevelProfileCreateInfoFB, in order. +#define XR_LIST_STRUCT_XrFoveationLevelProfileCreateInfoFB(_) \ + _(type) \ + _(next) \ + _(level) \ + _(verticalOffset) \ + _(dynamic) \ + +/// Calls your macro with the name of each member of XrSystemKeyboardTrackingPropertiesFB, in order. +#define XR_LIST_STRUCT_XrSystemKeyboardTrackingPropertiesFB(_) \ + _(type) \ + _(next) \ + _(supportsKeyboardTracking) \ + +/// Calls your macro with the name of each member of XrKeyboardTrackingDescriptionFB, in order. +#define XR_LIST_STRUCT_XrKeyboardTrackingDescriptionFB(_) \ + _(trackedKeyboardId) \ + _(size) \ + _(flags) \ + _(name) \ + +/// Calls your macro with the name of each member of XrKeyboardSpaceCreateInfoFB, in order. +#define XR_LIST_STRUCT_XrKeyboardSpaceCreateInfoFB(_) \ + _(type) \ + _(next) \ + _(trackedKeyboardId) \ + +/// Calls your macro with the name of each member of XrKeyboardTrackingQueryFB, in order. +#define XR_LIST_STRUCT_XrKeyboardTrackingQueryFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + +/// Calls your macro with the name of each member of XrTriangleMeshCreateInfoFB, in order. +#define XR_LIST_STRUCT_XrTriangleMeshCreateInfoFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + _(windingOrder) \ + _(vertexCount) \ + _(vertexBuffer) \ + _(triangleCount) \ + _(indexBuffer) \ + +/// Calls your macro with the name of each member of XrSystemPassthroughPropertiesFB, in order. +#define XR_LIST_STRUCT_XrSystemPassthroughPropertiesFB(_) \ + _(type) \ + _(next) \ + _(supportsPassthrough) \ + +/// Calls your macro with the name of each member of XrSystemPassthroughProperties2FB, in order. +#define XR_LIST_STRUCT_XrSystemPassthroughProperties2FB(_) \ + _(type) \ + _(next) \ + _(capabilities) \ + +/// Calls your macro with the name of each member of XrPassthroughCreateInfoFB, in order. +#define XR_LIST_STRUCT_XrPassthroughCreateInfoFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + +/// Calls your macro with the name of each member of XrPassthroughLayerCreateInfoFB, in order. +#define XR_LIST_STRUCT_XrPassthroughLayerCreateInfoFB(_) \ + _(type) \ + _(next) \ + _(passthrough) \ + _(flags) \ + _(purpose) \ + +/// Calls your macro with the name of each member of XrCompositionLayerPassthroughFB, in order. +#define XR_LIST_STRUCT_XrCompositionLayerPassthroughFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + _(space) \ + _(layerHandle) \ + +/// Calls your macro with the name of each member of XrGeometryInstanceCreateInfoFB, in order. +#define XR_LIST_STRUCT_XrGeometryInstanceCreateInfoFB(_) \ + _(type) \ + _(next) \ + _(layer) \ + _(mesh) \ + _(baseSpace) \ + _(pose) \ + _(scale) \ + +/// Calls your macro with the name of each member of XrGeometryInstanceTransformFB, in order. +#define XR_LIST_STRUCT_XrGeometryInstanceTransformFB(_) \ + _(type) \ + _(next) \ + _(baseSpace) \ + _(time) \ + _(pose) \ + _(scale) \ + +/// Calls your macro with the name of each member of XrPassthroughStyleFB, in order. +#define XR_LIST_STRUCT_XrPassthroughStyleFB(_) \ + _(type) \ + _(next) \ + _(textureOpacityFactor) \ + _(edgeColor) \ + +/// Calls your macro with the name of each member of XrPassthroughColorMapMonoToRgbaFB, in order. +#define XR_LIST_STRUCT_XrPassthroughColorMapMonoToRgbaFB(_) \ + _(type) \ + _(next) \ + _(textureColorMap) \ + +/// Calls your macro with the name of each member of XrPassthroughColorMapMonoToMonoFB, in order. +#define XR_LIST_STRUCT_XrPassthroughColorMapMonoToMonoFB(_) \ + _(type) \ + _(next) \ + _(textureColorMap) \ + +/// Calls your macro with the name of each member of XrPassthroughBrightnessContrastSaturationFB, in order. +#define XR_LIST_STRUCT_XrPassthroughBrightnessContrastSaturationFB(_) \ + _(type) \ + _(next) \ + _(brightness) \ + _(contrast) \ + _(saturation) \ + +/// Calls your macro with the name of each member of XrEventDataPassthroughStateChangedFB, in order. +#define XR_LIST_STRUCT_XrEventDataPassthroughStateChangedFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + +/// Calls your macro with the name of each member of XrRenderModelPathInfoFB, in order. +#define XR_LIST_STRUCT_XrRenderModelPathInfoFB(_) \ + _(type) \ + _(next) \ + _(path) \ + +/// Calls your macro with the name of each member of XrRenderModelPropertiesFB, in order. +#define XR_LIST_STRUCT_XrRenderModelPropertiesFB(_) \ + _(type) \ + _(next) \ + _(vendorId) \ + _(modelName) \ + _(modelKey) \ + _(modelVersion) \ + _(flags) \ + +/// Calls your macro with the name of each member of XrRenderModelBufferFB, in order. +#define XR_LIST_STRUCT_XrRenderModelBufferFB(_) \ + _(type) \ + _(next) \ + _(bufferCapacityInput) \ + _(bufferCountOutput) \ + _(buffer) \ + +/// Calls your macro with the name of each member of XrRenderModelLoadInfoFB, in order. +#define XR_LIST_STRUCT_XrRenderModelLoadInfoFB(_) \ + _(type) \ + _(next) \ + _(modelKey) \ + +/// Calls your macro with the name of each member of XrSystemRenderModelPropertiesFB, in order. +#define XR_LIST_STRUCT_XrSystemRenderModelPropertiesFB(_) \ + _(type) \ + _(next) \ + _(supportsRenderModelLoading) \ + +/// Calls your macro with the name of each member of XrRenderModelCapabilitiesRequestFB, in order. +#define XR_LIST_STRUCT_XrRenderModelCapabilitiesRequestFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + +/// Calls your macro with the name of each member of XrViewLocateFoveatedRenderingVARJO, in order. +#define XR_LIST_STRUCT_XrViewLocateFoveatedRenderingVARJO(_) \ + _(type) \ + _(next) \ + _(foveatedRenderingActive) \ + +/// Calls your macro with the name of each member of XrFoveatedViewConfigurationViewVARJO, in order. +#define XR_LIST_STRUCT_XrFoveatedViewConfigurationViewVARJO(_) \ + _(type) \ + _(next) \ + _(foveatedRenderingActive) \ + +/// Calls your macro with the name of each member of XrSystemFoveatedRenderingPropertiesVARJO, in order. +#define XR_LIST_STRUCT_XrSystemFoveatedRenderingPropertiesVARJO(_) \ + _(type) \ + _(next) \ + _(supportsFoveatedRendering) \ + +/// Calls your macro with the name of each member of XrCompositionLayerDepthTestVARJO, in order. +#define XR_LIST_STRUCT_XrCompositionLayerDepthTestVARJO(_) \ + _(type) \ + _(next) \ + _(depthTestRangeNearZ) \ + _(depthTestRangeFarZ) \ + +/// Calls your macro with the name of each member of XrSystemMarkerTrackingPropertiesVARJO, in order. +#define XR_LIST_STRUCT_XrSystemMarkerTrackingPropertiesVARJO(_) \ + _(type) \ + _(next) \ + _(supportsMarkerTracking) \ + +/// Calls your macro with the name of each member of XrEventDataMarkerTrackingUpdateVARJO, in order. +#define XR_LIST_STRUCT_XrEventDataMarkerTrackingUpdateVARJO(_) \ + _(type) \ + _(next) \ + _(markerId) \ + _(isActive) \ + _(isPredicted) \ + _(time) \ + +/// Calls your macro with the name of each member of XrMarkerSpaceCreateInfoVARJO, in order. +#define XR_LIST_STRUCT_XrMarkerSpaceCreateInfoVARJO(_) \ + _(type) \ + _(next) \ + _(markerId) \ + _(poseInMarkerSpace) \ + +/// Calls your macro with the name of each member of XrFrameEndInfoML, in order. +#define XR_LIST_STRUCT_XrFrameEndInfoML(_) \ + _(type) \ + _(next) \ + _(focusDistance) \ + _(flags) \ + +/// Calls your macro with the name of each member of XrGlobalDimmerFrameEndInfoML, in order. +#define XR_LIST_STRUCT_XrGlobalDimmerFrameEndInfoML(_) \ + _(type) \ + _(next) \ + _(dimmerValue) \ + _(flags) \ + +/// Calls your macro with the name of each member of XrCoordinateSpaceCreateInfoML, in order. +#define XR_LIST_STRUCT_XrCoordinateSpaceCreateInfoML(_) \ + _(type) \ + _(next) \ + _(cfuid) \ + _(poseInCoordinateSpace) \ + +/// Calls your macro with the name of each member of XrSystemMarkerUnderstandingPropertiesML, in order. +#define XR_LIST_STRUCT_XrSystemMarkerUnderstandingPropertiesML(_) \ + _(type) \ + _(next) \ + _(supportsMarkerUnderstanding) \ + +/// Calls your macro with the name of each member of XrMarkerDetectorCreateInfoML, in order. +#define XR_LIST_STRUCT_XrMarkerDetectorCreateInfoML(_) \ + _(type) \ + _(next) \ + _(profile) \ + _(markerType) \ + +/// Calls your macro with the name of each member of XrMarkerDetectorArucoInfoML, in order. +#define XR_LIST_STRUCT_XrMarkerDetectorArucoInfoML(_) \ + _(type) \ + _(next) \ + _(arucoDict) \ + +/// Calls your macro with the name of each member of XrMarkerDetectorSizeInfoML, in order. +#define XR_LIST_STRUCT_XrMarkerDetectorSizeInfoML(_) \ + _(type) \ + _(next) \ + _(markerLength) \ + +/// Calls your macro with the name of each member of XrMarkerDetectorAprilTagInfoML, in order. +#define XR_LIST_STRUCT_XrMarkerDetectorAprilTagInfoML(_) \ + _(type) \ + _(next) \ + _(aprilTagDict) \ + +/// Calls your macro with the name of each member of XrMarkerDetectorCustomProfileInfoML, in order. +#define XR_LIST_STRUCT_XrMarkerDetectorCustomProfileInfoML(_) \ + _(type) \ + _(next) \ + _(fpsHint) \ + _(resolutionHint) \ + _(cameraHint) \ + _(cornerRefineMethod) \ + _(useEdgeRefinement) \ + _(fullAnalysisIntervalHint) \ + +/// Calls your macro with the name of each member of XrMarkerDetectorSnapshotInfoML, in order. +#define XR_LIST_STRUCT_XrMarkerDetectorSnapshotInfoML(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrMarkerDetectorStateML, in order. +#define XR_LIST_STRUCT_XrMarkerDetectorStateML(_) \ + _(type) \ + _(next) \ + _(state) \ + +/// Calls your macro with the name of each member of XrMarkerSpaceCreateInfoML, in order. +#define XR_LIST_STRUCT_XrMarkerSpaceCreateInfoML(_) \ + _(type) \ + _(next) \ + _(markerDetector) \ + _(marker) \ + _(poseInMarkerSpace) \ + +/// Calls your macro with the name of each member of XrLocalizationMapML, in order. +#define XR_LIST_STRUCT_XrLocalizationMapML(_) \ + _(type) \ + _(next) \ + _(name) \ + _(mapUuid) \ + _(mapType) \ + +/// Calls your macro with the name of each member of XrEventDataLocalizationChangedML, in order. +#define XR_LIST_STRUCT_XrEventDataLocalizationChangedML(_) \ + _(type) \ + _(next) \ + _(session) \ + _(state) \ + _(map) \ + _(confidence) \ + _(errorFlags) \ + +/// Calls your macro with the name of each member of XrLocalizationMapQueryInfoBaseHeaderML, in order. +#define XR_LIST_STRUCT_XrLocalizationMapQueryInfoBaseHeaderML(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrMapLocalizationRequestInfoML, in order. +#define XR_LIST_STRUCT_XrMapLocalizationRequestInfoML(_) \ + _(type) \ + _(next) \ + _(mapUuid) \ + +/// Calls your macro with the name of each member of XrLocalizationMapImportInfoML, in order. +#define XR_LIST_STRUCT_XrLocalizationMapImportInfoML(_) \ + _(type) \ + _(next) \ + _(size) \ + _(data) \ + +/// Calls your macro with the name of each member of XrLocalizationEnableEventsInfoML, in order. +#define XR_LIST_STRUCT_XrLocalizationEnableEventsInfoML(_) \ + _(type) \ + _(next) \ + _(enabled) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorsCreateInfoBaseHeaderML, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorsCreateInfoBaseHeaderML(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorsCreateInfoFromPoseML, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorsCreateInfoFromPoseML(_) \ + _(type) \ + _(next) \ + _(baseSpace) \ + _(poseInBaseSpace) \ + _(time) \ + +/// Calls your macro with the name of each member of XrCreateSpatialAnchorsCompletionML, in order. +#define XR_LIST_STRUCT_XrCreateSpatialAnchorsCompletionML(_) \ + _(type) \ + _(next) \ + _(futureResult) \ + _(spaceCount) \ + _(spaces) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorStateML, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorStateML(_) \ + _(type) \ + _(next) \ + _(confidence) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorsCreateStorageInfoML, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorsCreateStorageInfoML(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorsQueryInfoBaseHeaderML, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorsQueryInfoBaseHeaderML(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorsQueryInfoRadiusML, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorsQueryInfoRadiusML(_) \ + _(type) \ + _(next) \ + _(baseSpace) \ + _(center) \ + _(time) \ + _(radius) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorsQueryCompletionML, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorsQueryCompletionML(_) \ + _(type) \ + _(next) \ + _(futureResult) \ + _(uuidCapacityInput) \ + _(uuidCountOutput) \ + _(uuids) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorsCreateInfoFromUuidsML, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorsCreateInfoFromUuidsML(_) \ + _(type) \ + _(next) \ + _(storage) \ + _(uuidCount) \ + _(uuids) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorsPublishInfoML, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorsPublishInfoML(_) \ + _(type) \ + _(next) \ + _(anchorCount) \ + _(anchors) \ + _(expiration) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorsPublishCompletionML, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorsPublishCompletionML(_) \ + _(type) \ + _(next) \ + _(futureResult) \ + _(uuidCount) \ + _(uuids) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorsDeleteInfoML, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorsDeleteInfoML(_) \ + _(type) \ + _(next) \ + _(uuidCount) \ + _(uuids) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorsDeleteCompletionML, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorsDeleteCompletionML(_) \ + _(type) \ + _(next) \ + _(futureResult) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorsUpdateExpirationInfoML, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorsUpdateExpirationInfoML(_) \ + _(type) \ + _(next) \ + _(uuidCount) \ + _(uuids) \ + _(expiration) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorsUpdateExpirationCompletionML, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorsUpdateExpirationCompletionML(_) \ + _(type) \ + _(next) \ + _(futureResult) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorCompletionResultML, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorCompletionResultML(_) \ + _(uuid) \ + _(result) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorsPublishCompletionDetailsML, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorsPublishCompletionDetailsML(_) \ + _(type) \ + _(next) \ + _(resultCount) \ + _(results) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorsDeleteCompletionDetailsML, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorsDeleteCompletionDetailsML(_) \ + _(type) \ + _(next) \ + _(resultCount) \ + _(results) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorsUpdateExpirationCompletionDetailsML, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorsUpdateExpirationCompletionDetailsML(_) \ + _(type) \ + _(next) \ + _(resultCount) \ + _(results) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorPersistenceNameMSFT, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorPersistenceNameMSFT(_) \ + _(name) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorPersistenceInfoMSFT, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorPersistenceInfoMSFT(_) \ + _(type) \ + _(next) \ + _(spatialAnchorPersistenceName) \ + _(spatialAnchor) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT(_) \ + _(type) \ + _(next) \ + _(spatialAnchorStore) \ + _(spatialAnchorPersistenceName) \ + +/// Calls your macro with the name of each member of XrSceneMarkerMSFT, in order. +#define XR_LIST_STRUCT_XrSceneMarkerMSFT(_) \ + _(markerType) \ + _(lastSeenTime) \ + _(center) \ + _(size) \ + +/// Calls your macro with the name of each member of XrSceneMarkersMSFT, in order. +#define XR_LIST_STRUCT_XrSceneMarkersMSFT(_) \ + _(type) \ + _(next) \ + _(sceneMarkerCapacityInput) \ + _(sceneMarkers) \ + +/// Calls your macro with the name of each member of XrSceneMarkerTypeFilterMSFT, in order. +#define XR_LIST_STRUCT_XrSceneMarkerTypeFilterMSFT(_) \ + _(type) \ + _(next) \ + _(markerTypeCount) \ + _(markerTypes) \ + +/// Calls your macro with the name of each member of XrSceneMarkerQRCodeMSFT, in order. +#define XR_LIST_STRUCT_XrSceneMarkerQRCodeMSFT(_) \ + _(symbolType) \ + _(version) \ + +/// Calls your macro with the name of each member of XrSceneMarkerQRCodesMSFT, in order. +#define XR_LIST_STRUCT_XrSceneMarkerQRCodesMSFT(_) \ + _(type) \ + _(next) \ + _(qrCodeCapacityInput) \ + _(qrCodes) \ + +/// Calls your macro with the name of each member of XrSpaceQueryInfoBaseHeaderFB, in order. +#define XR_LIST_STRUCT_XrSpaceQueryInfoBaseHeaderFB(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSpaceFilterInfoBaseHeaderFB, in order. +#define XR_LIST_STRUCT_XrSpaceFilterInfoBaseHeaderFB(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSpaceQueryInfoFB, in order. +#define XR_LIST_STRUCT_XrSpaceQueryInfoFB(_) \ + _(type) \ + _(next) \ + _(queryAction) \ + _(maxResultCount) \ + _(timeout) \ + _(filter) \ + _(excludeFilter) \ + +/// Calls your macro with the name of each member of XrSpaceStorageLocationFilterInfoFB, in order. +#define XR_LIST_STRUCT_XrSpaceStorageLocationFilterInfoFB(_) \ + _(type) \ + _(next) \ + _(location) \ + +/// Calls your macro with the name of each member of XrSpaceUuidFilterInfoFB, in order. +#define XR_LIST_STRUCT_XrSpaceUuidFilterInfoFB(_) \ + _(type) \ + _(next) \ + _(uuidCount) \ + _(uuids) \ + +/// Calls your macro with the name of each member of XrSpaceComponentFilterInfoFB, in order. +#define XR_LIST_STRUCT_XrSpaceComponentFilterInfoFB(_) \ + _(type) \ + _(next) \ + _(componentType) \ + +/// Calls your macro with the name of each member of XrSpaceQueryResultFB, in order. +#define XR_LIST_STRUCT_XrSpaceQueryResultFB(_) \ + _(space) \ + _(uuid) \ + +/// Calls your macro with the name of each member of XrSpaceQueryResultsFB, in order. +#define XR_LIST_STRUCT_XrSpaceQueryResultsFB(_) \ + _(type) \ + _(next) \ + _(resultCapacityInput) \ + _(resultCountOutput) \ + _(results) \ + +/// Calls your macro with the name of each member of XrEventDataSpaceQueryResultsAvailableFB, in order. +#define XR_LIST_STRUCT_XrEventDataSpaceQueryResultsAvailableFB(_) \ + _(type) \ + _(next) \ + _(requestId) \ + +/// Calls your macro with the name of each member of XrEventDataSpaceQueryCompleteFB, in order. +#define XR_LIST_STRUCT_XrEventDataSpaceQueryCompleteFB(_) \ + _(type) \ + _(next) \ + _(requestId) \ + _(result) \ + +/// Calls your macro with the name of each member of XrSpaceSaveInfoFB, in order. +#define XR_LIST_STRUCT_XrSpaceSaveInfoFB(_) \ + _(type) \ + _(next) \ + _(space) \ + _(location) \ + _(persistenceMode) \ + +/// Calls your macro with the name of each member of XrSpaceEraseInfoFB, in order. +#define XR_LIST_STRUCT_XrSpaceEraseInfoFB(_) \ + _(type) \ + _(next) \ + _(space) \ + _(location) \ + +/// Calls your macro with the name of each member of XrEventDataSpaceSaveCompleteFB, in order. +#define XR_LIST_STRUCT_XrEventDataSpaceSaveCompleteFB(_) \ + _(type) \ + _(next) \ + _(requestId) \ + _(result) \ + _(space) \ + _(uuid) \ + _(location) \ + +/// Calls your macro with the name of each member of XrEventDataSpaceEraseCompleteFB, in order. +#define XR_LIST_STRUCT_XrEventDataSpaceEraseCompleteFB(_) \ + _(type) \ + _(next) \ + _(requestId) \ + _(result) \ + _(space) \ + _(uuid) \ + _(location) \ + +/// Calls your macro with the name of each member of XrSwapchainImageFoveationVulkanFB, in order. +#define XR_LIST_STRUCT_XrSwapchainImageFoveationVulkanFB(_) \ + _(type) \ + _(next) \ + _(image) \ + _(width) \ + _(height) \ + +/// Calls your macro with the name of each member of XrSwapchainStateAndroidSurfaceDimensionsFB, in order. +#define XR_LIST_STRUCT_XrSwapchainStateAndroidSurfaceDimensionsFB(_) \ + _(type) \ + _(next) \ + _(width) \ + _(height) \ + +/// Calls your macro with the name of each member of XrSwapchainStateSamplerOpenGLESFB, in order. +#define XR_LIST_STRUCT_XrSwapchainStateSamplerOpenGLESFB(_) \ + _(type) \ + _(next) \ + _(minFilter) \ + _(magFilter) \ + _(wrapModeS) \ + _(wrapModeT) \ + _(swizzleRed) \ + _(swizzleGreen) \ + _(swizzleBlue) \ + _(swizzleAlpha) \ + _(maxAnisotropy) \ + _(borderColor) \ + +/// Calls your macro with the name of each member of XrSwapchainStateSamplerVulkanFB, in order. +#define XR_LIST_STRUCT_XrSwapchainStateSamplerVulkanFB(_) \ + _(type) \ + _(next) \ + _(minFilter) \ + _(magFilter) \ + _(mipmapMode) \ + _(wrapModeS) \ + _(wrapModeT) \ + _(swizzleRed) \ + _(swizzleGreen) \ + _(swizzleBlue) \ + _(swizzleAlpha) \ + _(maxAnisotropy) \ + _(borderColor) \ + +/// Calls your macro with the name of each member of XrSpaceShareInfoFB, in order. +#define XR_LIST_STRUCT_XrSpaceShareInfoFB(_) \ + _(type) \ + _(next) \ + _(spaceCount) \ + _(spaces) \ + _(userCount) \ + _(users) \ + +/// Calls your macro with the name of each member of XrEventDataSpaceShareCompleteFB, in order. +#define XR_LIST_STRUCT_XrEventDataSpaceShareCompleteFB(_) \ + _(type) \ + _(next) \ + _(requestId) \ + _(result) \ + +/// Calls your macro with the name of each member of XrCompositionLayerSpaceWarpInfoFB, in order. +#define XR_LIST_STRUCT_XrCompositionLayerSpaceWarpInfoFB(_) \ + _(type) \ + _(next) \ + _(layerFlags) \ + _(motionVectorSubImage) \ + _(appSpaceDeltaPose) \ + _(depthSubImage) \ + _(minDepth) \ + _(maxDepth) \ + _(nearZ) \ + _(farZ) \ + +/// Calls your macro with the name of each member of XrSystemSpaceWarpPropertiesFB, in order. +#define XR_LIST_STRUCT_XrSystemSpaceWarpPropertiesFB(_) \ + _(type) \ + _(next) \ + _(recommendedMotionVectorImageRectWidth) \ + _(recommendedMotionVectorImageRectHeight) \ + +/// Calls your macro with the name of each member of XrHapticAmplitudeEnvelopeVibrationFB, in order. +#define XR_LIST_STRUCT_XrHapticAmplitudeEnvelopeVibrationFB(_) \ + _(type) \ + _(next) \ + _(duration) \ + _(amplitudeCount) \ + _(amplitudes) \ + +/// Calls your macro with the name of each member of XrOffset3DfFB, in order. +#define XR_LIST_STRUCT_XrOffset3DfFB(_) \ + _(x) \ + _(y) \ + _(z) \ + +/// Calls your macro with the name of each member of XrRect3DfFB, in order. +#define XR_LIST_STRUCT_XrRect3DfFB(_) \ + _(offset) \ + _(extent) \ + +/// Calls your macro with the name of each member of XrSemanticLabelsFB, in order. +#define XR_LIST_STRUCT_XrSemanticLabelsFB(_) \ + _(type) \ + _(next) \ + _(bufferCapacityInput) \ + _(bufferCountOutput) \ + _(buffer) \ + +/// Calls your macro with the name of each member of XrRoomLayoutFB, in order. +#define XR_LIST_STRUCT_XrRoomLayoutFB(_) \ + _(type) \ + _(next) \ + _(floorUuid) \ + _(ceilingUuid) \ + _(wallUuidCapacityInput) \ + _(wallUuidCountOutput) \ + _(wallUuids) \ + +/// Calls your macro with the name of each member of XrBoundary2DFB, in order. +#define XR_LIST_STRUCT_XrBoundary2DFB(_) \ + _(type) \ + _(next) \ + _(vertexCapacityInput) \ + _(vertexCountOutput) \ + _(vertices) \ + +/// Calls your macro with the name of each member of XrSemanticLabelsSupportInfoFB, in order. +#define XR_LIST_STRUCT_XrSemanticLabelsSupportInfoFB(_) \ + _(type) \ + _(next) \ + _(flags) \ + _(recognizedLabels) \ + +/// Calls your macro with the name of each member of XrDigitalLensControlALMALENCE, in order. +#define XR_LIST_STRUCT_XrDigitalLensControlALMALENCE(_) \ + _(type) \ + _(next) \ + _(flags) \ + +/// Calls your macro with the name of each member of XrEventDataSceneCaptureCompleteFB, in order. +#define XR_LIST_STRUCT_XrEventDataSceneCaptureCompleteFB(_) \ + _(type) \ + _(next) \ + _(requestId) \ + _(result) \ + +/// Calls your macro with the name of each member of XrSceneCaptureRequestInfoFB, in order. +#define XR_LIST_STRUCT_XrSceneCaptureRequestInfoFB(_) \ + _(type) \ + _(next) \ + _(requestByteCount) \ + _(request) \ + +/// Calls your macro with the name of each member of XrSpaceContainerFB, in order. +#define XR_LIST_STRUCT_XrSpaceContainerFB(_) \ + _(type) \ + _(next) \ + _(uuidCapacityInput) \ + _(uuidCountOutput) \ + _(uuids) \ + +/// Calls your macro with the name of each member of XrFoveationEyeTrackedProfileCreateInfoMETA, in order. +#define XR_LIST_STRUCT_XrFoveationEyeTrackedProfileCreateInfoMETA(_) \ + _(type) \ + _(next) \ + _(flags) \ + +/// Calls your macro with the name of each member of XrFoveationEyeTrackedStateMETA, in order. +#define XR_LIST_STRUCT_XrFoveationEyeTrackedStateMETA(_) \ + _(type) \ + _(next) \ + _(foveationCenter) \ + _(flags) \ + +/// Calls your macro with the name of each member of XrSystemFoveationEyeTrackedPropertiesMETA, in order. +#define XR_LIST_STRUCT_XrSystemFoveationEyeTrackedPropertiesMETA(_) \ + _(type) \ + _(next) \ + _(supportsFoveationEyeTracked) \ + +/// Calls your macro with the name of each member of XrSystemFaceTrackingPropertiesFB, in order. +#define XR_LIST_STRUCT_XrSystemFaceTrackingPropertiesFB(_) \ + _(type) \ + _(next) \ + _(supportsFaceTracking) \ + +/// Calls your macro with the name of each member of XrFaceTrackerCreateInfoFB, in order. +#define XR_LIST_STRUCT_XrFaceTrackerCreateInfoFB(_) \ + _(type) \ + _(next) \ + _(faceExpressionSet) \ + +/// Calls your macro with the name of each member of XrFaceExpressionInfoFB, in order. +#define XR_LIST_STRUCT_XrFaceExpressionInfoFB(_) \ + _(type) \ + _(next) \ + _(time) \ + +/// Calls your macro with the name of each member of XrFaceExpressionStatusFB, in order. +#define XR_LIST_STRUCT_XrFaceExpressionStatusFB(_) \ + _(isValid) \ + _(isEyeFollowingBlendshapesValid) \ + +/// Calls your macro with the name of each member of XrFaceExpressionWeightsFB, in order. +#define XR_LIST_STRUCT_XrFaceExpressionWeightsFB(_) \ + _(type) \ + _(next) \ + _(weightCount) \ + _(weights) \ + _(confidenceCount) \ + _(confidences) \ + _(status) \ + _(time) \ + +/// Calls your macro with the name of each member of XrEyeGazeFB, in order. +#define XR_LIST_STRUCT_XrEyeGazeFB(_) \ + _(isValid) \ + _(gazePose) \ + _(gazeConfidence) \ + +/// Calls your macro with the name of each member of XrEyeTrackerCreateInfoFB, in order. +#define XR_LIST_STRUCT_XrEyeTrackerCreateInfoFB(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrEyeGazesInfoFB, in order. +#define XR_LIST_STRUCT_XrEyeGazesInfoFB(_) \ + _(type) \ + _(next) \ + _(baseSpace) \ + _(time) \ + +/// Calls your macro with the name of each member of XrSystemEyeTrackingPropertiesFB, in order. +#define XR_LIST_STRUCT_XrSystemEyeTrackingPropertiesFB(_) \ + _(type) \ + _(next) \ + _(supportsEyeTracking) \ + +/// Calls your macro with the name of each member of XrEyeGazesFB, in order. +#define XR_LIST_STRUCT_XrEyeGazesFB(_) \ + _(type) \ + _(next) \ + _(gaze) \ + _(time) \ + +/// Calls your macro with the name of each member of XrPassthroughKeyboardHandsIntensityFB, in order. +#define XR_LIST_STRUCT_XrPassthroughKeyboardHandsIntensityFB(_) \ + _(type) \ + _(next) \ + _(leftHandIntensity) \ + _(rightHandIntensity) \ + +/// Calls your macro with the name of each member of XrCompositionLayerSettingsFB, in order. +#define XR_LIST_STRUCT_XrCompositionLayerSettingsFB(_) \ + _(type) \ + _(next) \ + _(layerFlags) \ + +/// Calls your macro with the name of each member of XrHapticPcmVibrationFB, in order. +#define XR_LIST_STRUCT_XrHapticPcmVibrationFB(_) \ + _(type) \ + _(next) \ + _(bufferSize) \ + _(buffer) \ + _(sampleRate) \ + _(append) \ + _(samplesConsumed) \ + +/// Calls your macro with the name of each member of XrDevicePcmSampleRateStateFB, in order. +#define XR_LIST_STRUCT_XrDevicePcmSampleRateStateFB(_) \ + _(type) \ + _(next) \ + _(sampleRate) \ + +/// Calls your macro with the name of each member of XrFrameSynthesisInfoEXT, in order. +#define XR_LIST_STRUCT_XrFrameSynthesisInfoEXT(_) \ + _(type) \ + _(next) \ + _(layerFlags) \ + _(motionVectorSubImage) \ + _(motionVectorScale) \ + _(motionVectorOffset) \ + _(appSpaceDeltaPose) \ + _(depthSubImage) \ + _(minDepth) \ + _(maxDepth) \ + _(nearZ) \ + _(farZ) \ + +/// Calls your macro with the name of each member of XrFrameSynthesisConfigViewEXT, in order. +#define XR_LIST_STRUCT_XrFrameSynthesisConfigViewEXT(_) \ + _(type) \ + _(next) \ + _(recommendedMotionVectorImageRectWidth) \ + _(recommendedMotionVectorImageRectHeight) \ + +/// Calls your macro with the name of each member of XrCompositionLayerDepthTestFB, in order. +#define XR_LIST_STRUCT_XrCompositionLayerDepthTestFB(_) \ + _(type) \ + _(next) \ + _(depthMask) \ + _(compareOp) \ + +/// Calls your macro with the name of each member of XrLocalDimmingFrameEndInfoMETA, in order. +#define XR_LIST_STRUCT_XrLocalDimmingFrameEndInfoMETA(_) \ + _(type) \ + _(next) \ + _(localDimmingMode) \ + +/// Calls your macro with the name of each member of XrPassthroughPreferencesMETA, in order. +#define XR_LIST_STRUCT_XrPassthroughPreferencesMETA(_) \ + _(type) \ + _(next) \ + _(flags) \ + +/// Calls your macro with the name of each member of XrSystemVirtualKeyboardPropertiesMETA, in order. +#define XR_LIST_STRUCT_XrSystemVirtualKeyboardPropertiesMETA(_) \ + _(type) \ + _(next) \ + _(supportsVirtualKeyboard) \ + +/// Calls your macro with the name of each member of XrVirtualKeyboardCreateInfoMETA, in order. +#define XR_LIST_STRUCT_XrVirtualKeyboardCreateInfoMETA(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrVirtualKeyboardSpaceCreateInfoMETA, in order. +#define XR_LIST_STRUCT_XrVirtualKeyboardSpaceCreateInfoMETA(_) \ + _(type) \ + _(next) \ + _(locationType) \ + _(space) \ + _(poseInSpace) \ + +/// Calls your macro with the name of each member of XrVirtualKeyboardLocationInfoMETA, in order. +#define XR_LIST_STRUCT_XrVirtualKeyboardLocationInfoMETA(_) \ + _(type) \ + _(next) \ + _(locationType) \ + _(space) \ + _(poseInSpace) \ + _(scale) \ + +/// Calls your macro with the name of each member of XrVirtualKeyboardModelVisibilitySetInfoMETA, in order. +#define XR_LIST_STRUCT_XrVirtualKeyboardModelVisibilitySetInfoMETA(_) \ + _(type) \ + _(next) \ + _(visible) \ + +/// Calls your macro with the name of each member of XrVirtualKeyboardAnimationStateMETA, in order. +#define XR_LIST_STRUCT_XrVirtualKeyboardAnimationStateMETA(_) \ + _(type) \ + _(next) \ + _(animationIndex) \ + _(fraction) \ + +/// Calls your macro with the name of each member of XrVirtualKeyboardModelAnimationStatesMETA, in order. +#define XR_LIST_STRUCT_XrVirtualKeyboardModelAnimationStatesMETA(_) \ + _(type) \ + _(next) \ + _(stateCapacityInput) \ + _(stateCountOutput) \ + _(states) \ + +/// Calls your macro with the name of each member of XrVirtualKeyboardTextureDataMETA, in order. +#define XR_LIST_STRUCT_XrVirtualKeyboardTextureDataMETA(_) \ + _(type) \ + _(next) \ + _(textureWidth) \ + _(textureHeight) \ + _(bufferCapacityInput) \ + _(bufferCountOutput) \ + _(buffer) \ + +/// Calls your macro with the name of each member of XrVirtualKeyboardInputInfoMETA, in order. +#define XR_LIST_STRUCT_XrVirtualKeyboardInputInfoMETA(_) \ + _(type) \ + _(next) \ + _(inputSource) \ + _(inputSpace) \ + _(inputPoseInSpace) \ + _(inputState) \ + +/// Calls your macro with the name of each member of XrVirtualKeyboardTextContextChangeInfoMETA, in order. +#define XR_LIST_STRUCT_XrVirtualKeyboardTextContextChangeInfoMETA(_) \ + _(type) \ + _(next) \ + _(textContext) \ + +/// Calls your macro with the name of each member of XrEventDataVirtualKeyboardCommitTextMETA, in order. +#define XR_LIST_STRUCT_XrEventDataVirtualKeyboardCommitTextMETA(_) \ + _(type) \ + _(next) \ + _(keyboard) \ + _(text) \ + +/// Calls your macro with the name of each member of XrEventDataVirtualKeyboardBackspaceMETA, in order. +#define XR_LIST_STRUCT_XrEventDataVirtualKeyboardBackspaceMETA(_) \ + _(type) \ + _(next) \ + _(keyboard) \ + +/// Calls your macro with the name of each member of XrEventDataVirtualKeyboardEnterMETA, in order. +#define XR_LIST_STRUCT_XrEventDataVirtualKeyboardEnterMETA(_) \ + _(type) \ + _(next) \ + _(keyboard) \ + +/// Calls your macro with the name of each member of XrEventDataVirtualKeyboardShownMETA, in order. +#define XR_LIST_STRUCT_XrEventDataVirtualKeyboardShownMETA(_) \ + _(type) \ + _(next) \ + _(keyboard) \ + +/// Calls your macro with the name of each member of XrEventDataVirtualKeyboardHiddenMETA, in order. +#define XR_LIST_STRUCT_XrEventDataVirtualKeyboardHiddenMETA(_) \ + _(type) \ + _(next) \ + _(keyboard) \ + +/// Calls your macro with the name of each member of XrExternalCameraIntrinsicsOCULUS, in order. +#define XR_LIST_STRUCT_XrExternalCameraIntrinsicsOCULUS(_) \ + _(lastChangeTime) \ + _(fov) \ + _(virtualNearPlaneDistance) \ + _(virtualFarPlaneDistance) \ + _(imageSensorPixelResolution) \ + +/// Calls your macro with the name of each member of XrExternalCameraExtrinsicsOCULUS, in order. +#define XR_LIST_STRUCT_XrExternalCameraExtrinsicsOCULUS(_) \ + _(lastChangeTime) \ + _(cameraStatusFlags) \ + _(attachedToDevice) \ + _(relativePose) \ + +/// Calls your macro with the name of each member of XrExternalCameraOCULUS, in order. +#define XR_LIST_STRUCT_XrExternalCameraOCULUS(_) \ + _(type) \ + _(next) \ + _(name) \ + _(intrinsics) \ + _(extrinsics) \ + +/// Calls your macro with the name of each member of XrVulkanSwapchainCreateInfoMETA, in order. +#define XR_LIST_STRUCT_XrVulkanSwapchainCreateInfoMETA(_) \ + _(type) \ + _(next) \ + _(additionalCreateFlags) \ + _(additionalUsageFlags) \ + +/// Calls your macro with the name of each member of XrPerformanceMetricsStateMETA, in order. +#define XR_LIST_STRUCT_XrPerformanceMetricsStateMETA(_) \ + _(type) \ + _(next) \ + _(enabled) \ + +/// Calls your macro with the name of each member of XrPerformanceMetricsCounterMETA, in order. +#define XR_LIST_STRUCT_XrPerformanceMetricsCounterMETA(_) \ + _(type) \ + _(next) \ + _(counterFlags) \ + _(counterUnit) \ + _(uintValue) \ + _(floatValue) \ + +/// Calls your macro with the name of each member of XrSpaceListSaveInfoFB, in order. +#define XR_LIST_STRUCT_XrSpaceListSaveInfoFB(_) \ + _(type) \ + _(next) \ + _(spaceCount) \ + _(spaces) \ + _(location) \ + +/// Calls your macro with the name of each member of XrEventDataSpaceListSaveCompleteFB, in order. +#define XR_LIST_STRUCT_XrEventDataSpaceListSaveCompleteFB(_) \ + _(type) \ + _(next) \ + _(requestId) \ + _(result) \ + +/// Calls your macro with the name of each member of XrSpaceUserCreateInfoFB, in order. +#define XR_LIST_STRUCT_XrSpaceUserCreateInfoFB(_) \ + _(type) \ + _(next) \ + _(userId) \ + +/// Calls your macro with the name of each member of XrSystemHeadsetIdPropertiesMETA, in order. +#define XR_LIST_STRUCT_XrSystemHeadsetIdPropertiesMETA(_) \ + _(type) \ + _(next) \ + _(id) \ + +/// Calls your macro with the name of each member of XrSystemSpaceDiscoveryPropertiesMETA, in order. +#define XR_LIST_STRUCT_XrSystemSpaceDiscoveryPropertiesMETA(_) \ + _(type) \ + _(next) \ + _(supportsSpaceDiscovery) \ + +/// Calls your macro with the name of each member of XrSpaceFilterBaseHeaderMETA, in order. +#define XR_LIST_STRUCT_XrSpaceFilterBaseHeaderMETA(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSpaceDiscoveryInfoMETA, in order. +#define XR_LIST_STRUCT_XrSpaceDiscoveryInfoMETA(_) \ + _(type) \ + _(next) \ + _(filterCount) \ + _(filters) \ + +/// Calls your macro with the name of each member of XrSpaceFilterUuidMETA, in order. +#define XR_LIST_STRUCT_XrSpaceFilterUuidMETA(_) \ + _(type) \ + _(next) \ + _(uuidCount) \ + _(uuids) \ + +/// Calls your macro with the name of each member of XrSpaceFilterComponentMETA, in order. +#define XR_LIST_STRUCT_XrSpaceFilterComponentMETA(_) \ + _(type) \ + _(next) \ + _(componentType) \ + +/// Calls your macro with the name of each member of XrSpaceDiscoveryResultMETA, in order. +#define XR_LIST_STRUCT_XrSpaceDiscoveryResultMETA(_) \ + _(space) \ + _(uuid) \ + +/// Calls your macro with the name of each member of XrSpaceDiscoveryResultsMETA, in order. +#define XR_LIST_STRUCT_XrSpaceDiscoveryResultsMETA(_) \ + _(type) \ + _(next) \ + _(resultCapacityInput) \ + _(resultCountOutput) \ + _(results) \ + +/// Calls your macro with the name of each member of XrEventDataSpaceDiscoveryResultsAvailableMETA, in order. +#define XR_LIST_STRUCT_XrEventDataSpaceDiscoveryResultsAvailableMETA(_) \ + _(type) \ + _(next) \ + _(requestId) \ + +/// Calls your macro with the name of each member of XrEventDataSpaceDiscoveryCompleteMETA, in order. +#define XR_LIST_STRUCT_XrEventDataSpaceDiscoveryCompleteMETA(_) \ + _(type) \ + _(next) \ + _(requestId) \ + _(result) \ + +/// Calls your macro with the name of each member of XrRecommendedLayerResolutionMETA, in order. +#define XR_LIST_STRUCT_XrRecommendedLayerResolutionMETA(_) \ + _(type) \ + _(next) \ + _(recommendedImageDimensions) \ + _(isValid) \ + +/// Calls your macro with the name of each member of XrRecommendedLayerResolutionGetInfoMETA, in order. +#define XR_LIST_STRUCT_XrRecommendedLayerResolutionGetInfoMETA(_) \ + _(type) \ + _(next) \ + _(layer) \ + _(predictedDisplayTime) \ + +/// Calls your macro with the name of each member of XrSystemSpacePersistencePropertiesMETA, in order. +#define XR_LIST_STRUCT_XrSystemSpacePersistencePropertiesMETA(_) \ + _(type) \ + _(next) \ + _(supportsSpacePersistence) \ + +/// Calls your macro with the name of each member of XrSpacesSaveInfoMETA, in order. +#define XR_LIST_STRUCT_XrSpacesSaveInfoMETA(_) \ + _(type) \ + _(next) \ + _(spaceCount) \ + _(spaces) \ + +/// Calls your macro with the name of each member of XrEventDataSpacesSaveResultMETA, in order. +#define XR_LIST_STRUCT_XrEventDataSpacesSaveResultMETA(_) \ + _(type) \ + _(next) \ + _(requestId) \ + _(result) \ + +/// Calls your macro with the name of each member of XrSpacesEraseInfoMETA, in order. +#define XR_LIST_STRUCT_XrSpacesEraseInfoMETA(_) \ + _(type) \ + _(next) \ + _(spaceCount) \ + _(spaces) \ + _(uuidCount) \ + _(uuids) \ + +/// Calls your macro with the name of each member of XrEventDataSpacesEraseResultMETA, in order. +#define XR_LIST_STRUCT_XrEventDataSpacesEraseResultMETA(_) \ + _(type) \ + _(next) \ + _(requestId) \ + _(result) \ + +/// Calls your macro with the name of each member of XrPassthroughColorLutDataMETA, in order. +#define XR_LIST_STRUCT_XrPassthroughColorLutDataMETA(_) \ + _(bufferSize) \ + _(buffer) \ + +/// Calls your macro with the name of each member of XrPassthroughColorLutCreateInfoMETA, in order. +#define XR_LIST_STRUCT_XrPassthroughColorLutCreateInfoMETA(_) \ + _(type) \ + _(next) \ + _(channels) \ + _(resolution) \ + _(data) \ + +/// Calls your macro with the name of each member of XrPassthroughColorLutUpdateInfoMETA, in order. +#define XR_LIST_STRUCT_XrPassthroughColorLutUpdateInfoMETA(_) \ + _(type) \ + _(next) \ + _(data) \ + +/// Calls your macro with the name of each member of XrPassthroughColorMapLutMETA, in order. +#define XR_LIST_STRUCT_XrPassthroughColorMapLutMETA(_) \ + _(type) \ + _(next) \ + _(colorLut) \ + _(weight) \ + +/// Calls your macro with the name of each member of XrPassthroughColorMapInterpolatedLutMETA, in order. +#define XR_LIST_STRUCT_XrPassthroughColorMapInterpolatedLutMETA(_) \ + _(type) \ + _(next) \ + _(sourceColorLut) \ + _(targetColorLut) \ + _(weight) \ + +/// Calls your macro with the name of each member of XrSystemPassthroughColorLutPropertiesMETA, in order. +#define XR_LIST_STRUCT_XrSystemPassthroughColorLutPropertiesMETA(_) \ + _(type) \ + _(next) \ + _(maxColorLutResolution) \ + +/// Calls your macro with the name of each member of XrSpaceTriangleMeshGetInfoMETA, in order. +#define XR_LIST_STRUCT_XrSpaceTriangleMeshGetInfoMETA(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSpaceTriangleMeshMETA, in order. +#define XR_LIST_STRUCT_XrSpaceTriangleMeshMETA(_) \ + _(type) \ + _(next) \ + _(vertexCapacityInput) \ + _(vertexCountOutput) \ + _(vertices) \ + _(indexCapacityInput) \ + _(indexCountOutput) \ + _(indices) \ + +/// Calls your macro with the name of each member of XrSystemPropertiesBodyTrackingFullBodyMETA, in order. +#define XR_LIST_STRUCT_XrSystemPropertiesBodyTrackingFullBodyMETA(_) \ + _(type) \ + _(next) \ + _(supportsFullBodyTracking) \ + +/// Calls your macro with the name of each member of XrEventDataPassthroughLayerResumedMETA, in order. +#define XR_LIST_STRUCT_XrEventDataPassthroughLayerResumedMETA(_) \ + _(type) \ + _(next) \ + _(layer) \ + +/// Calls your macro with the name of each member of XrBodyTrackingCalibrationStatusMETA, in order. +#define XR_LIST_STRUCT_XrBodyTrackingCalibrationStatusMETA(_) \ + _(type) \ + _(next) \ + _(status) \ + +/// Calls your macro with the name of each member of XrBodyTrackingCalibrationInfoMETA, in order. +#define XR_LIST_STRUCT_XrBodyTrackingCalibrationInfoMETA(_) \ + _(type) \ + _(next) \ + _(bodyHeight) \ + +/// Calls your macro with the name of each member of XrSystemPropertiesBodyTrackingCalibrationMETA, in order. +#define XR_LIST_STRUCT_XrSystemPropertiesBodyTrackingCalibrationMETA(_) \ + _(type) \ + _(next) \ + _(supportsHeightOverride) \ + +/// Calls your macro with the name of each member of XrSystemPropertiesBodyTrackingFidelityMETA, in order. +#define XR_LIST_STRUCT_XrSystemPropertiesBodyTrackingFidelityMETA(_) \ + _(type) \ + _(next) \ + _(supportsBodyTrackingFidelity) \ + +/// Calls your macro with the name of each member of XrBodyTrackingFidelityStatusMETA, in order. +#define XR_LIST_STRUCT_XrBodyTrackingFidelityStatusMETA(_) \ + _(type) \ + _(next) \ + _(fidelity) \ + +/// Calls your macro with the name of each member of XrSystemFaceTrackingProperties2FB, in order. +#define XR_LIST_STRUCT_XrSystemFaceTrackingProperties2FB(_) \ + _(type) \ + _(next) \ + _(supportsVisualFaceTracking) \ + _(supportsAudioFaceTracking) \ + +/// Calls your macro with the name of each member of XrFaceTrackerCreateInfo2FB, in order. +#define XR_LIST_STRUCT_XrFaceTrackerCreateInfo2FB(_) \ + _(type) \ + _(next) \ + _(faceExpressionSet) \ + _(requestedDataSourceCount) \ + _(requestedDataSources) \ + +/// Calls your macro with the name of each member of XrFaceExpressionInfo2FB, in order. +#define XR_LIST_STRUCT_XrFaceExpressionInfo2FB(_) \ + _(type) \ + _(next) \ + _(time) \ + +/// Calls your macro with the name of each member of XrFaceExpressionWeights2FB, in order. +#define XR_LIST_STRUCT_XrFaceExpressionWeights2FB(_) \ + _(type) \ + _(next) \ + _(weightCount) \ + _(weights) \ + _(confidenceCount) \ + _(confidences) \ + _(isValid) \ + _(isEyeFollowingBlendshapesValid) \ + _(dataSource) \ + _(time) \ + +/// Calls your macro with the name of each member of XrSystemSpatialEntitySharingPropertiesMETA, in order. +#define XR_LIST_STRUCT_XrSystemSpatialEntitySharingPropertiesMETA(_) \ + _(type) \ + _(next) \ + _(supportsSpatialEntitySharing) \ + +/// Calls your macro with the name of each member of XrShareSpacesRecipientBaseHeaderMETA, in order. +#define XR_LIST_STRUCT_XrShareSpacesRecipientBaseHeaderMETA(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrShareSpacesInfoMETA, in order. +#define XR_LIST_STRUCT_XrShareSpacesInfoMETA(_) \ + _(type) \ + _(next) \ + _(spaceCount) \ + _(spaces) \ + _(recipientInfo) \ + +/// Calls your macro with the name of each member of XrEventDataShareSpacesCompleteMETA, in order. +#define XR_LIST_STRUCT_XrEventDataShareSpacesCompleteMETA(_) \ + _(type) \ + _(next) \ + _(requestId) \ + _(result) \ + +/// Calls your macro with the name of each member of XrEnvironmentDepthProviderCreateInfoMETA, in order. +#define XR_LIST_STRUCT_XrEnvironmentDepthProviderCreateInfoMETA(_) \ + _(type) \ + _(next) \ + _(createFlags) \ + +/// Calls your macro with the name of each member of XrEnvironmentDepthSwapchainCreateInfoMETA, in order. +#define XR_LIST_STRUCT_XrEnvironmentDepthSwapchainCreateInfoMETA(_) \ + _(type) \ + _(next) \ + _(createFlags) \ + +/// Calls your macro with the name of each member of XrEnvironmentDepthSwapchainStateMETA, in order. +#define XR_LIST_STRUCT_XrEnvironmentDepthSwapchainStateMETA(_) \ + _(type) \ + _(next) \ + _(width) \ + _(height) \ + +/// Calls your macro with the name of each member of XrEnvironmentDepthImageAcquireInfoMETA, in order. +#define XR_LIST_STRUCT_XrEnvironmentDepthImageAcquireInfoMETA(_) \ + _(type) \ + _(next) \ + _(space) \ + _(displayTime) \ + +/// Calls your macro with the name of each member of XrEnvironmentDepthImageViewMETA, in order. +#define XR_LIST_STRUCT_XrEnvironmentDepthImageViewMETA(_) \ + _(type) \ + _(next) \ + _(fov) \ + _(pose) \ + +/// Calls your macro with the name of each member of XrEnvironmentDepthImageMETA, in order. +#define XR_LIST_STRUCT_XrEnvironmentDepthImageMETA(_) \ + _(type) \ + _(next) \ + _(swapchainIndex) \ + _(nearZ) \ + _(farZ) \ + _(views) \ + +/// Calls your macro with the name of each member of XrEnvironmentDepthImageTimestampMETA, in order. +#define XR_LIST_STRUCT_XrEnvironmentDepthImageTimestampMETA(_) \ + _(type) \ + _(next) \ + _(captureTime) \ + +/// Calls your macro with the name of each member of XrEnvironmentDepthHandRemovalSetInfoMETA, in order. +#define XR_LIST_STRUCT_XrEnvironmentDepthHandRemovalSetInfoMETA(_) \ + _(type) \ + _(next) \ + _(enabled) \ + +/// Calls your macro with the name of each member of XrSystemEnvironmentDepthPropertiesMETA, in order. +#define XR_LIST_STRUCT_XrSystemEnvironmentDepthPropertiesMETA(_) \ + _(type) \ + _(next) \ + _(supportsEnvironmentDepth) \ + _(supportsHandRemoval) \ + +/// Calls your macro with the name of each member of XrRenderModelCreateInfoEXT, in order. +#define XR_LIST_STRUCT_XrRenderModelCreateInfoEXT(_) \ + _(type) \ + _(next) \ + _(renderModelId) \ + _(gltfExtensionCount) \ + _(gltfExtensions) \ + +/// Calls your macro with the name of each member of XrRenderModelPropertiesGetInfoEXT, in order. +#define XR_LIST_STRUCT_XrRenderModelPropertiesGetInfoEXT(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrRenderModelPropertiesEXT, in order. +#define XR_LIST_STRUCT_XrRenderModelPropertiesEXT(_) \ + _(type) \ + _(next) \ + _(cacheId) \ + _(animatableNodeCount) \ + +/// Calls your macro with the name of each member of XrRenderModelSpaceCreateInfoEXT, in order. +#define XR_LIST_STRUCT_XrRenderModelSpaceCreateInfoEXT(_) \ + _(type) \ + _(next) \ + _(renderModel) \ + +/// Calls your macro with the name of each member of XrRenderModelStateGetInfoEXT, in order. +#define XR_LIST_STRUCT_XrRenderModelStateGetInfoEXT(_) \ + _(type) \ + _(next) \ + _(displayTime) \ + +/// Calls your macro with the name of each member of XrRenderModelNodeStateEXT, in order. +#define XR_LIST_STRUCT_XrRenderModelNodeStateEXT(_) \ + _(nodePose) \ + _(isVisible) \ + +/// Calls your macro with the name of each member of XrRenderModelStateEXT, in order. +#define XR_LIST_STRUCT_XrRenderModelStateEXT(_) \ + _(type) \ + _(next) \ + _(nodeStateCount) \ + _(nodeStates) \ + +/// Calls your macro with the name of each member of XrRenderModelAssetCreateInfoEXT, in order. +#define XR_LIST_STRUCT_XrRenderModelAssetCreateInfoEXT(_) \ + _(type) \ + _(next) \ + _(cacheId) \ + +/// Calls your macro with the name of each member of XrRenderModelAssetDataGetInfoEXT, in order. +#define XR_LIST_STRUCT_XrRenderModelAssetDataGetInfoEXT(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrRenderModelAssetDataEXT, in order. +#define XR_LIST_STRUCT_XrRenderModelAssetDataEXT(_) \ + _(type) \ + _(next) \ + _(bufferCapacityInput) \ + _(bufferCountOutput) \ + _(buffer) \ + +/// Calls your macro with the name of each member of XrRenderModelAssetPropertiesGetInfoEXT, in order. +#define XR_LIST_STRUCT_XrRenderModelAssetPropertiesGetInfoEXT(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrRenderModelAssetNodePropertiesEXT, in order. +#define XR_LIST_STRUCT_XrRenderModelAssetNodePropertiesEXT(_) \ + _(uniqueName) \ + +/// Calls your macro with the name of each member of XrRenderModelAssetPropertiesEXT, in order. +#define XR_LIST_STRUCT_XrRenderModelAssetPropertiesEXT(_) \ + _(type) \ + _(next) \ + _(nodePropertyCount) \ + _(nodeProperties) \ + +/// Calls your macro with the name of each member of XrInteractionRenderModelIdsEnumerateInfoEXT, in order. +#define XR_LIST_STRUCT_XrInteractionRenderModelIdsEnumerateInfoEXT(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrInteractionRenderModelSubactionPathInfoEXT, in order. +#define XR_LIST_STRUCT_XrInteractionRenderModelSubactionPathInfoEXT(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrInteractionRenderModelTopLevelUserPathGetInfoEXT, in order. +#define XR_LIST_STRUCT_XrInteractionRenderModelTopLevelUserPathGetInfoEXT(_) \ + _(type) \ + _(next) \ + _(topLevelUserPathCount) \ + _(topLevelUserPaths) \ + +/// Calls your macro with the name of each member of XrEventDataInteractionRenderModelsChangedEXT, in order. +#define XR_LIST_STRUCT_XrEventDataInteractionRenderModelsChangedEXT(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrHandGestureQCOM, in order. +#define XR_LIST_STRUCT_XrHandGestureQCOM(_) \ + _(gesture) \ + _(gestureRatio) \ + _(flipRatio) \ + +/// Calls your macro with the name of each member of XrPassthroughCreateInfoHTC, in order. +#define XR_LIST_STRUCT_XrPassthroughCreateInfoHTC(_) \ + _(type) \ + _(next) \ + _(form) \ + +/// Calls your macro with the name of each member of XrPassthroughColorHTC, in order. +#define XR_LIST_STRUCT_XrPassthroughColorHTC(_) \ + _(type) \ + _(next) \ + _(alpha) \ + +/// Calls your macro with the name of each member of XrPassthroughMeshTransformInfoHTC, in order. +#define XR_LIST_STRUCT_XrPassthroughMeshTransformInfoHTC(_) \ + _(type) \ + _(next) \ + _(vertexCount) \ + _(vertices) \ + _(indexCount) \ + _(indices) \ + _(baseSpace) \ + _(time) \ + _(pose) \ + _(scale) \ + +/// Calls your macro with the name of each member of XrCompositionLayerPassthroughHTC, in order. +#define XR_LIST_STRUCT_XrCompositionLayerPassthroughHTC(_) \ + _(type) \ + _(next) \ + _(layerFlags) \ + _(space) \ + _(passthrough) \ + _(color) \ + +/// Calls your macro with the name of each member of XrFoveationApplyInfoHTC, in order. +#define XR_LIST_STRUCT_XrFoveationApplyInfoHTC(_) \ + _(type) \ + _(next) \ + _(mode) \ + _(subImageCount) \ + _(subImages) \ + +/// Calls your macro with the name of each member of XrFoveationConfigurationHTC, in order. +#define XR_LIST_STRUCT_XrFoveationConfigurationHTC(_) \ + _(level) \ + _(clearFovDegree) \ + _(focalCenterOffset) \ + +/// Calls your macro with the name of each member of XrFoveationDynamicModeInfoHTC, in order. +#define XR_LIST_STRUCT_XrFoveationDynamicModeInfoHTC(_) \ + _(type) \ + _(next) \ + _(dynamicFlags) \ + +/// Calls your macro with the name of each member of XrFoveationCustomModeInfoHTC, in order. +#define XR_LIST_STRUCT_XrFoveationCustomModeInfoHTC(_) \ + _(type) \ + _(next) \ + _(configCount) \ + _(configs) \ + +/// Calls your macro with the name of each member of XrSystemAnchorPropertiesHTC, in order. +#define XR_LIST_STRUCT_XrSystemAnchorPropertiesHTC(_) \ + _(type) \ + _(next) \ + _(supportsAnchor) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorNameHTC, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorNameHTC(_) \ + _(name) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorCreateInfoHTC, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorCreateInfoHTC(_) \ + _(type) \ + _(next) \ + _(space) \ + _(poseInSpace) \ + _(name) \ + +/// Calls your macro with the name of each member of XrSystemBodyTrackingPropertiesHTC, in order. +#define XR_LIST_STRUCT_XrSystemBodyTrackingPropertiesHTC(_) \ + _(type) \ + _(next) \ + _(supportsBodyTracking) \ + +/// Calls your macro with the name of each member of XrBodyTrackerCreateInfoHTC, in order. +#define XR_LIST_STRUCT_XrBodyTrackerCreateInfoHTC(_) \ + _(type) \ + _(next) \ + _(bodyJointSet) \ + +/// Calls your macro with the name of each member of XrBodyJointsLocateInfoHTC, in order. +#define XR_LIST_STRUCT_XrBodyJointsLocateInfoHTC(_) \ + _(type) \ + _(next) \ + _(baseSpace) \ + _(time) \ + +/// Calls your macro with the name of each member of XrBodyJointLocationHTC, in order. +#define XR_LIST_STRUCT_XrBodyJointLocationHTC(_) \ + _(locationFlags) \ + _(pose) \ + +/// Calls your macro with the name of each member of XrBodyJointLocationsHTC, in order. +#define XR_LIST_STRUCT_XrBodyJointLocationsHTC(_) \ + _(type) \ + _(next) \ + _(combinedLocationFlags) \ + _(confidenceLevel) \ + _(jointLocationCount) \ + _(jointLocations) \ + _(skeletonGenerationId) \ + +/// Calls your macro with the name of each member of XrBodySkeletonJointHTC, in order. +#define XR_LIST_STRUCT_XrBodySkeletonJointHTC(_) \ + _(pose) \ + +/// Calls your macro with the name of each member of XrBodySkeletonHTC, in order. +#define XR_LIST_STRUCT_XrBodySkeletonHTC(_) \ + _(type) \ + _(next) \ + _(jointCount) \ + _(joints) \ + +/// Calls your macro with the name of each member of XrActiveActionSetPriorityEXT, in order. +#define XR_LIST_STRUCT_XrActiveActionSetPriorityEXT(_) \ + _(actionSet) \ + _(priorityOverride) \ + +/// Calls your macro with the name of each member of XrActiveActionSetPrioritiesEXT, in order. +#define XR_LIST_STRUCT_XrActiveActionSetPrioritiesEXT(_) \ + _(type) \ + _(next) \ + _(actionSetPriorityCount) \ + _(actionSetPriorities) \ + +/// Calls your macro with the name of each member of XrSystemForceFeedbackCurlPropertiesMNDX, in order. +#define XR_LIST_STRUCT_XrSystemForceFeedbackCurlPropertiesMNDX(_) \ + _(type) \ + _(next) \ + _(supportsForceFeedbackCurl) \ + +/// Calls your macro with the name of each member of XrForceFeedbackCurlApplyLocationMNDX, in order. +#define XR_LIST_STRUCT_XrForceFeedbackCurlApplyLocationMNDX(_) \ + _(location) \ + _(value) \ + +/// Calls your macro with the name of each member of XrForceFeedbackCurlApplyLocationsMNDX, in order. +#define XR_LIST_STRUCT_XrForceFeedbackCurlApplyLocationsMNDX(_) \ + _(type) \ + _(next) \ + _(locationCount) \ + _(locations) \ + +/// Calls your macro with the name of each member of XrSystemBodyTrackingPropertiesBD, in order. +#define XR_LIST_STRUCT_XrSystemBodyTrackingPropertiesBD(_) \ + _(type) \ + _(next) \ + _(supportsBodyTracking) \ + +/// Calls your macro with the name of each member of XrBodyTrackerCreateInfoBD, in order. +#define XR_LIST_STRUCT_XrBodyTrackerCreateInfoBD(_) \ + _(type) \ + _(next) \ + _(jointSet) \ + +/// Calls your macro with the name of each member of XrBodyJointsLocateInfoBD, in order. +#define XR_LIST_STRUCT_XrBodyJointsLocateInfoBD(_) \ + _(type) \ + _(next) \ + _(baseSpace) \ + _(time) \ + +/// Calls your macro with the name of each member of XrBodyJointLocationBD, in order. +#define XR_LIST_STRUCT_XrBodyJointLocationBD(_) \ + _(locationFlags) \ + _(pose) \ + +/// Calls your macro with the name of each member of XrBodyJointLocationsBD, in order. +#define XR_LIST_STRUCT_XrBodyJointLocationsBD(_) \ + _(type) \ + _(next) \ + _(allJointPosesTracked) \ + _(jointLocationCount) \ + _(jointLocations) \ + +/// Calls your macro with the name of each member of XrSystemFacialSimulationPropertiesBD, in order. +#define XR_LIST_STRUCT_XrSystemFacialSimulationPropertiesBD(_) \ + _(type) \ + _(next) \ + _(supportsFaceTracking) \ + +/// Calls your macro with the name of each member of XrFaceTrackerCreateInfoBD, in order. +#define XR_LIST_STRUCT_XrFaceTrackerCreateInfoBD(_) \ + _(type) \ + _(next) \ + _(mode) \ + +/// Calls your macro with the name of each member of XrFacialSimulationDataGetInfoBD, in order. +#define XR_LIST_STRUCT_XrFacialSimulationDataGetInfoBD(_) \ + _(type) \ + _(next) \ + _(time) \ + +/// Calls your macro with the name of each member of XrFacialSimulationDataBD, in order. +#define XR_LIST_STRUCT_XrFacialSimulationDataBD(_) \ + _(type) \ + _(next) \ + _(faceExpressionWeightCount) \ + _(faceExpressionWeights) \ + _(isUpperFaceDataValid) \ + _(isLowerFaceDataValid) \ + _(time) \ + +/// Calls your macro with the name of each member of XrLipExpressionDataBD, in order. +#define XR_LIST_STRUCT_XrLipExpressionDataBD(_) \ + _(type) \ + _(next) \ + _(lipsyncExpressionWeightCount) \ + _(lipsyncExpressionWeights) \ + +/// Calls your macro with the name of each member of XrSystemSpatialSensingPropertiesBD, in order. +#define XR_LIST_STRUCT_XrSystemSpatialSensingPropertiesBD(_) \ + _(type) \ + _(next) \ + _(supportsSpatialSensing) \ + +/// Calls your macro with the name of each member of XrSpatialEntityComponentGetInfoBD, in order. +#define XR_LIST_STRUCT_XrSpatialEntityComponentGetInfoBD(_) \ + _(type) \ + _(next) \ + _(entityId) \ + _(componentType) \ + +/// Calls your macro with the name of each member of XrSpatialEntityComponentDataBaseHeaderBD, in order. +#define XR_LIST_STRUCT_XrSpatialEntityComponentDataBaseHeaderBD(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSpatialEntityLocationGetInfoBD, in order. +#define XR_LIST_STRUCT_XrSpatialEntityLocationGetInfoBD(_) \ + _(type) \ + _(next) \ + _(baseSpace) \ + +/// Calls your macro with the name of each member of XrSpatialEntityComponentDataLocationBD, in order. +#define XR_LIST_STRUCT_XrSpatialEntityComponentDataLocationBD(_) \ + _(type) \ + _(next) \ + _(location) \ + +/// Calls your macro with the name of each member of XrSpatialEntityComponentDataSemanticBD, in order. +#define XR_LIST_STRUCT_XrSpatialEntityComponentDataSemanticBD(_) \ + _(type) \ + _(next) \ + _(labelCapacityInput) \ + _(labelCountOutput) \ + _(labels) \ + +/// Calls your macro with the name of each member of XrSpatialEntityComponentDataBoundingBox2DBD, in order. +#define XR_LIST_STRUCT_XrSpatialEntityComponentDataBoundingBox2DBD(_) \ + _(type) \ + _(next) \ + _(boundingBox2D) \ + +/// Calls your macro with the name of each member of XrSpatialEntityComponentDataPolygonBD, in order. +#define XR_LIST_STRUCT_XrSpatialEntityComponentDataPolygonBD(_) \ + _(type) \ + _(next) \ + _(vertexCapacityInput) \ + _(vertexCountOutput) \ + _(vertices) \ + +/// Calls your macro with the name of each member of XrSpatialEntityComponentDataBoundingBox3DBD, in order. +#define XR_LIST_STRUCT_XrSpatialEntityComponentDataBoundingBox3DBD(_) \ + _(type) \ + _(next) \ + _(boundingBox3D) \ + +/// Calls your macro with the name of each member of XrSpatialEntityComponentDataTriangleMeshBD, in order. +#define XR_LIST_STRUCT_XrSpatialEntityComponentDataTriangleMeshBD(_) \ + _(type) \ + _(next) \ + _(vertexCapacityInput) \ + _(vertexCountOutput) \ + _(vertices) \ + _(indexCapacityInput) \ + _(indexCountOutput) \ + _(indices) \ + +/// Calls your macro with the name of each member of XrSpatialEntityComponentDataSphereBD, in order. +#define XR_LIST_STRUCT_XrSpatialEntityComponentDataSphereBD(_) \ + _(type) \ + _(next) \ + _(sphere) \ + +/// Calls your macro with the name of each member of XrSenseDataProviderCreateInfoBD, in order. +#define XR_LIST_STRUCT_XrSenseDataProviderCreateInfoBD(_) \ + _(type) \ + _(next) \ + _(providerType) \ + +/// Calls your macro with the name of each member of XrSenseDataProviderStartInfoBD, in order. +#define XR_LIST_STRUCT_XrSenseDataProviderStartInfoBD(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrEventDataSenseDataProviderStateChangedBD, in order. +#define XR_LIST_STRUCT_XrEventDataSenseDataProviderStateChangedBD(_) \ + _(type) \ + _(next) \ + _(provider) \ + _(newState) \ + +/// Calls your macro with the name of each member of XrEventDataSenseDataUpdatedBD, in order. +#define XR_LIST_STRUCT_XrEventDataSenseDataUpdatedBD(_) \ + _(type) \ + _(next) \ + _(provider) \ + +/// Calls your macro with the name of each member of XrSenseDataQueryInfoBD, in order. +#define XR_LIST_STRUCT_XrSenseDataQueryInfoBD(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSenseDataQueryCompletionBD, in order. +#define XR_LIST_STRUCT_XrSenseDataQueryCompletionBD(_) \ + _(type) \ + _(next) \ + _(futureResult) \ + _(snapshot) \ + +/// Calls your macro with the name of each member of XrQueriedSenseDataGetInfoBD, in order. +#define XR_LIST_STRUCT_XrQueriedSenseDataGetInfoBD(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSpatialEntityStateBD, in order. +#define XR_LIST_STRUCT_XrSpatialEntityStateBD(_) \ + _(type) \ + _(next) \ + _(entityId) \ + _(lastUpdateTime) \ + _(uuid) \ + +/// Calls your macro with the name of each member of XrQueriedSenseDataBD, in order. +#define XR_LIST_STRUCT_XrQueriedSenseDataBD(_) \ + _(type) \ + _(next) \ + _(stateCapacityInput) \ + _(stateCountOutput) \ + _(states) \ + +/// Calls your macro with the name of each member of XrSenseDataFilterUuidBD, in order. +#define XR_LIST_STRUCT_XrSenseDataFilterUuidBD(_) \ + _(type) \ + _(next) \ + _(uuidCount) \ + _(uuids) \ + +/// Calls your macro with the name of each member of XrSenseDataFilterSemanticBD, in order. +#define XR_LIST_STRUCT_XrSenseDataFilterSemanticBD(_) \ + _(type) \ + _(next) \ + _(labelCount) \ + _(labels) \ + +/// Calls your macro with the name of each member of XrSpatialEntityAnchorCreateInfoBD, in order. +#define XR_LIST_STRUCT_XrSpatialEntityAnchorCreateInfoBD(_) \ + _(type) \ + _(next) \ + _(snapshot) \ + _(entityId) \ + +/// Calls your macro with the name of each member of XrAnchorSpaceCreateInfoBD, in order. +#define XR_LIST_STRUCT_XrAnchorSpaceCreateInfoBD(_) \ + _(type) \ + _(next) \ + _(anchor) \ + _(poseInAnchorSpace) \ + +/// Calls your macro with the name of each member of XrFutureCompletionEXT, in order. +#define XR_LIST_STRUCT_XrFutureCompletionEXT(_) \ + _(type) \ + _(next) \ + _(futureResult) \ + +/// Calls your macro with the name of each member of XrSystemSpatialAnchorPropertiesBD, in order. +#define XR_LIST_STRUCT_XrSystemSpatialAnchorPropertiesBD(_) \ + _(type) \ + _(next) \ + _(supportsSpatialAnchor) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorCreateInfoBD, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorCreateInfoBD(_) \ + _(type) \ + _(next) \ + _(space) \ + _(pose) \ + _(time) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorCreateCompletionBD, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorCreateCompletionBD(_) \ + _(type) \ + _(next) \ + _(futureResult) \ + _(uuid) \ + _(anchor) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorPersistInfoBD, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorPersistInfoBD(_) \ + _(type) \ + _(next) \ + _(location) \ + _(anchor) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorUnpersistInfoBD, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorUnpersistInfoBD(_) \ + _(type) \ + _(next) \ + _(location) \ + _(anchor) \ + +/// Calls your macro with the name of each member of XrSystemSpatialAnchorSharingPropertiesBD, in order. +#define XR_LIST_STRUCT_XrSystemSpatialAnchorSharingPropertiesBD(_) \ + _(type) \ + _(next) \ + _(supportsSpatialAnchorSharing) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorShareInfoBD, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorShareInfoBD(_) \ + _(type) \ + _(next) \ + _(anchor) \ + +/// Calls your macro with the name of each member of XrSharedSpatialAnchorDownloadInfoBD, in order. +#define XR_LIST_STRUCT_XrSharedSpatialAnchorDownloadInfoBD(_) \ + _(type) \ + _(next) \ + _(uuid) \ + +/// Calls your macro with the name of each member of XrSystemSpatialScenePropertiesBD, in order. +#define XR_LIST_STRUCT_XrSystemSpatialScenePropertiesBD(_) \ + _(type) \ + _(next) \ + _(supportsSpatialScene) \ + +/// Calls your macro with the name of each member of XrSceneCaptureInfoBD, in order. +#define XR_LIST_STRUCT_XrSceneCaptureInfoBD(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSystemSpatialMeshPropertiesBD, in order. +#define XR_LIST_STRUCT_XrSystemSpatialMeshPropertiesBD(_) \ + _(type) \ + _(next) \ + _(supportsSpatialMesh) \ + +/// Calls your macro with the name of each member of XrSenseDataProviderCreateInfoSpatialMeshBD, in order. +#define XR_LIST_STRUCT_XrSenseDataProviderCreateInfoSpatialMeshBD(_) \ + _(type) \ + _(next) \ + _(configFlags) \ + _(lod) \ + +/// Calls your macro with the name of each member of XrFuturePollResultProgressBD, in order. +#define XR_LIST_STRUCT_XrFuturePollResultProgressBD(_) \ + _(type) \ + _(next) \ + _(isSupported) \ + _(progressPercentage) \ + +/// Calls your macro with the name of each member of XrBodyTrackingPostureDataBD, in order. +#define XR_LIST_STRUCT_XrBodyTrackingPostureDataBD(_) \ + _(type) \ + _(next) \ + _(postureCount) \ + _(postureData) \ + +/// Calls your macro with the name of each member of XrBodyJointVelocityBD, in order. +#define XR_LIST_STRUCT_XrBodyJointVelocityBD(_) \ + _(velocityFlags) \ + _(linearVelocity) \ + _(angularVelocity) \ + +/// Calls your macro with the name of each member of XrBodyJointVelocitiesBD, in order. +#define XR_LIST_STRUCT_XrBodyJointVelocitiesBD(_) \ + _(type) \ + _(next) \ + _(velocityCount) \ + _(velocities) \ + +/// Calls your macro with the name of each member of XrBodyJointAccelerationBD, in order. +#define XR_LIST_STRUCT_XrBodyJointAccelerationBD(_) \ + _(accelerationFlags) \ + _(linearAcceleration) \ + _(angularAcceleration) \ + +/// Calls your macro with the name of each member of XrBodyJointAccelerationsBD, in order. +#define XR_LIST_STRUCT_XrBodyJointAccelerationsBD(_) \ + _(type) \ + _(next) \ + _(accelerationCount) \ + _(accelerations) \ + +/// Calls your macro with the name of each member of XrBodyTrackingStateBD, in order. +#define XR_LIST_STRUCT_XrBodyTrackingStateBD(_) \ + _(type) \ + _(next) \ + _(status) \ + _(message) \ + +/// Calls your macro with the name of each member of XrSystemSpatialPlanePropertiesBD, in order. +#define XR_LIST_STRUCT_XrSystemSpatialPlanePropertiesBD(_) \ + _(type) \ + _(next) \ + _(supportsSpatialPlane) \ + +/// Calls your macro with the name of each member of XrSpatialEntityComponentDataPlaneOrientationBD, in order. +#define XR_LIST_STRUCT_XrSpatialEntityComponentDataPlaneOrientationBD(_) \ + _(type) \ + _(next) \ + _(orientation) \ + +/// Calls your macro with the name of each member of XrSenseDataFilterPlaneOrientationBD, in order. +#define XR_LIST_STRUCT_XrSenseDataFilterPlaneOrientationBD(_) \ + _(type) \ + _(next) \ + _(orientationCount) \ + _(orientations) \ + +/// Calls your macro with the name of each member of XrSystemLightEstimationPropertiesBD, in order. +#define XR_LIST_STRUCT_XrSystemLightEstimationPropertiesBD(_) \ + _(type) \ + _(next) \ + _(supportsLightEstimation) \ + _(supportsEnvironmentTexture) \ + _(supportsSphericalHarmonics) \ + +/// Calls your macro with the name of each member of XrSenseDataProviderCreateInfoLightEstimationBD, in order. +#define XR_LIST_STRUCT_XrSenseDataProviderCreateInfoLightEstimationBD(_) \ + _(type) \ + _(next) \ + _(createFlags) \ + +/// Calls your macro with the name of each member of XrEnvironmentTextureCreateConfigInfoBD, in order. +#define XR_LIST_STRUCT_XrEnvironmentTextureCreateConfigInfoBD(_) \ + _(type) \ + _(next) \ + _(pixelFormat) \ + _(resolution) \ + _(transferType) \ + +/// Calls your macro with the name of each member of XrLightEstimationDataEnvironmentTextureRawBD, in order. +#define XR_LIST_STRUCT_XrLightEstimationDataEnvironmentTextureRawBD(_) \ + _(type) \ + _(next) \ + _(pixelFormat) \ + _(cubemapFaceBufferSize) \ + _(rightCubemapFaceBuffer) \ + _(leftCubemapFaceBuffer) \ + _(topCubemapFaceBuffer) \ + _(bottomCubemapFaceBuffer) \ + _(frontCubemapFaceBuffer) \ + _(backCubemapFaceBuffer) \ + +/// Calls your macro with the name of each member of XrLightEstimationDataSphericalHarmonicsBD, in order. +#define XR_LIST_STRUCT_XrLightEstimationDataSphericalHarmonicsBD(_) \ + _(type) \ + _(next) \ + _(kind) \ + _(coefficientCapacityInput) \ + _(coefficientCountOutput) \ + _(coefficients) \ + +/// Calls your macro with the name of each member of XrSpatialEntityComponentDataLightEstimationBD, in order. +#define XR_LIST_STRUCT_XrSpatialEntityComponentDataLightEstimationBD(_) \ + _(type) \ + _(next) \ + _(isValid) \ + +/// Calls your macro with the name of each member of XrSpatialAudioRendererCreateInfoBD, in order. +#define XR_LIST_STRUCT_XrSpatialAudioRendererCreateInfoBD(_) \ + _(type) \ + _(next) \ + _(framesPerBuffer) \ + _(sampleRate) \ + +/// Calls your macro with the name of each member of XrAudioBufferBD, in order. +#define XR_LIST_STRUCT_XrAudioBufferBD(_) \ + _(type) \ + _(next) \ + _(channelLayout) \ + _(bufferChannels) \ + _(bufferLength) \ + _(buffer) \ + +/// Calls your macro with the name of each member of XrSoundObjectDirectivityCardioidBD, in order. +#define XR_LIST_STRUCT_XrSoundObjectDirectivityCardioidBD(_) \ + _(type) \ + _(next) \ + _(alpha) \ + _(order) \ + +/// Calls your macro with the name of each member of XrSoundObjectShapeSphereBD, in order. +#define XR_LIST_STRUCT_XrSoundObjectShapeSphereBD(_) \ + _(type) \ + _(next) \ + _(radius) \ + +/// Calls your macro with the name of each member of XrAttenuationCurvePointBD, in order. +#define XR_LIST_STRUCT_XrAttenuationCurvePointBD(_) \ + _(distance) \ + _(gain) \ + +/// Calls your macro with the name of each member of XrSoundObjectDistanceAttenuationCurveBD, in order. +#define XR_LIST_STRUCT_XrSoundObjectDistanceAttenuationCurveBD(_) \ + _(type) \ + _(next) \ + _(curvePointCount) \ + _(curvePoints) \ + +/// Calls your macro with the name of each member of XrSoundObjectDistanceAttenuationBD, in order. +#define XR_LIST_STRUCT_XrSoundObjectDistanceAttenuationBD(_) \ + _(type) \ + _(next) \ + _(distanceAttenuationType) \ + _(minAttenuationRange) \ + _(maxAttenuationRange) \ + _(referenceDistance) \ + _(rolloffFactor) \ + _(customDistanceAttenuationCurve) \ + +/// Calls your macro with the name of each member of XrSoundObjectConfigBD, in order. +#define XR_LIST_STRUCT_XrSoundObjectConfigBD(_) \ + _(type) \ + _(next) \ + _(enabled) \ + _(pose) \ + _(baseSpace) \ + _(mainVolume) \ + _(reflectionGain) \ + _(enableDoppler) \ + _(directSoundAttenuation) \ + _(indirectSoundAttenuation) \ + +/// Calls your macro with the name of each member of XrSoundFieldConfigBD, in order. +#define XR_LIST_STRUCT_XrSoundFieldConfigBD(_) \ + _(type) \ + _(next) \ + _(enabled) \ + _(orientation) \ + _(baseSpace) \ + _(mainVolume) \ + _(lfeGain) \ + +/// Calls your macro with the name of each member of XrSoundFieldChannelDefinitionSurroundBD, in order. +#define XR_LIST_STRUCT_XrSoundFieldChannelDefinitionSurroundBD(_) \ + _(type) \ + _(next) \ + _(channelMask) \ + +/// Calls your macro with the name of each member of XrSoundFieldChannelDefinitionAmbixBD, in order. +#define XR_LIST_STRUCT_XrSoundFieldChannelDefinitionAmbixBD(_) \ + _(type) \ + _(next) \ + _(channelMask) \ + +/// Calls your macro with the name of each member of XrSoundFieldChannelDefinitionFumaBD, in order. +#define XR_LIST_STRUCT_XrSoundFieldChannelDefinitionFumaBD(_) \ + _(type) \ + _(next) \ + _(channelMask) \ + +/// Calls your macro with the name of each member of XrSoundTriangleMeshBD, in order. +#define XR_LIST_STRUCT_XrSoundTriangleMeshBD(_) \ + _(type) \ + _(next) \ + _(vertexCount) \ + _(vertices) \ + _(indexCount) \ + _(indices) \ + +/// Calls your macro with the name of each member of XrSoundObstacleConfigBD, in order. +#define XR_LIST_STRUCT_XrSoundObstacleConfigBD(_) \ + _(type) \ + _(next) \ + _(enabled) \ + _(pose) \ + _(baseSpace) \ + _(materialCount) \ + _(materials) \ + +/// Calls your macro with the name of each member of XrSoundObstacleMaterialConfigBD, in order. +#define XR_LIST_STRUCT_XrSoundObstacleMaterialConfigBD(_) \ + _(type) \ + _(next) \ + _(materialType) \ + _(bandCount) \ + _(bandFrequencies) \ + _(bandAbsorptions) \ + _(bandScatterings) \ + _(bandTransmissions) \ + +/// Calls your macro with the name of each member of XrHandTrackingDataSourceInfoEXT, in order. +#define XR_LIST_STRUCT_XrHandTrackingDataSourceInfoEXT(_) \ + _(type) \ + _(next) \ + _(requestedDataSourceCount) \ + _(requestedDataSources) \ + +/// Calls your macro with the name of each member of XrHandTrackingDataSourceStateEXT, in order. +#define XR_LIST_STRUCT_XrHandTrackingDataSourceStateEXT(_) \ + _(type) \ + _(next) \ + _(isActive) \ + _(dataSource) \ + +/// Calls your macro with the name of each member of XrSystemPlaneDetectionPropertiesEXT, in order. +#define XR_LIST_STRUCT_XrSystemPlaneDetectionPropertiesEXT(_) \ + _(type) \ + _(next) \ + _(supportedFeatures) \ + +/// Calls your macro with the name of each member of XrPlaneDetectorCreateInfoEXT, in order. +#define XR_LIST_STRUCT_XrPlaneDetectorCreateInfoEXT(_) \ + _(type) \ + _(next) \ + _(flags) \ + +/// Calls your macro with the name of each member of XrPlaneDetectorBeginInfoEXT, in order. +#define XR_LIST_STRUCT_XrPlaneDetectorBeginInfoEXT(_) \ + _(type) \ + _(next) \ + _(baseSpace) \ + _(time) \ + _(orientationCount) \ + _(orientations) \ + _(semanticTypeCount) \ + _(semanticTypes) \ + _(maxPlanes) \ + _(minArea) \ + _(boundingBoxPose) \ + _(boundingBoxExtent) \ + +/// Calls your macro with the name of each member of XrPlaneDetectorGetInfoEXT, in order. +#define XR_LIST_STRUCT_XrPlaneDetectorGetInfoEXT(_) \ + _(type) \ + _(next) \ + _(baseSpace) \ + _(time) \ + +/// Calls your macro with the name of each member of XrPlaneDetectorLocationEXT, in order. +#define XR_LIST_STRUCT_XrPlaneDetectorLocationEXT(_) \ + _(type) \ + _(next) \ + _(planeId) \ + _(locationFlags) \ + _(pose) \ + _(extents) \ + _(orientation) \ + _(semanticType) \ + _(polygonBufferCount) \ + +/// Calls your macro with the name of each member of XrPlaneDetectorLocationsEXT, in order. +#define XR_LIST_STRUCT_XrPlaneDetectorLocationsEXT(_) \ + _(type) \ + _(next) \ + _(planeLocationCapacityInput) \ + _(planeLocationCountOutput) \ + _(planeLocations) \ + +/// Calls your macro with the name of each member of XrPlaneDetectorPolygonBufferEXT, in order. +#define XR_LIST_STRUCT_XrPlaneDetectorPolygonBufferEXT(_) \ + _(type) \ + _(next) \ + _(vertexCapacityInput) \ + _(vertexCountOutput) \ + _(vertices) \ + +/// Calls your macro with the name of each member of XrTrackableTrackerCreateInfoANDROID, in order. +#define XR_LIST_STRUCT_XrTrackableTrackerCreateInfoANDROID(_) \ + _(type) \ + _(next) \ + _(trackableType) \ + +/// Calls your macro with the name of each member of XrTrackableGetInfoANDROID, in order. +#define XR_LIST_STRUCT_XrTrackableGetInfoANDROID(_) \ + _(type) \ + _(next) \ + _(trackable) \ + _(baseSpace) \ + _(time) \ + +/// Calls your macro with the name of each member of XrTrackablePlaneANDROID, in order. +#define XR_LIST_STRUCT_XrTrackablePlaneANDROID(_) \ + _(type) \ + _(next) \ + _(trackingState) \ + _(centerPose) \ + _(extents) \ + _(planeType) \ + _(planeLabel) \ + _(subsumedByPlane) \ + _(lastUpdatedTime) \ + _(vertexCapacityInput) \ + _(vertexCountOutput) \ + _(vertices) \ + +/// Calls your macro with the name of each member of XrAnchorSpaceCreateInfoANDROID, in order. +#define XR_LIST_STRUCT_XrAnchorSpaceCreateInfoANDROID(_) \ + _(type) \ + _(next) \ + _(space) \ + _(time) \ + _(pose) \ + _(trackable) \ + +/// Calls your macro with the name of each member of XrSystemTrackablesPropertiesANDROID, in order. +#define XR_LIST_STRUCT_XrSystemTrackablesPropertiesANDROID(_) \ + _(type) \ + _(next) \ + _(supportsAnchor) \ + _(maxAnchors) \ + +/// Calls your macro with the name of each member of XrSystemEyeTrackingPropertiesANDROID, in order. +#define XR_LIST_STRUCT_XrSystemEyeTrackingPropertiesANDROID(_) \ + _(type) \ + _(next) \ + _(supportsEyeTracking) \ + +/// Calls your macro with the name of each member of XrEyeANDROID, in order. +#define XR_LIST_STRUCT_XrEyeANDROID(_) \ + _(eyeState) \ + _(eyePose) \ + +/// Calls your macro with the name of each member of XrEyesANDROID, in order. +#define XR_LIST_STRUCT_XrEyesANDROID(_) \ + _(type) \ + _(next) \ + _(eyes) \ + _(mode) \ + +/// Calls your macro with the name of each member of XrEyesGetInfoANDROID, in order. +#define XR_LIST_STRUCT_XrEyesGetInfoANDROID(_) \ + _(type) \ + _(next) \ + _(time) \ + _(baseSpace) \ + +/// Calls your macro with the name of each member of XrEyeTrackerCreateInfoANDROID, in order. +#define XR_LIST_STRUCT_XrEyeTrackerCreateInfoANDROID(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrDeviceAnchorPersistenceCreateInfoANDROID, in order. +#define XR_LIST_STRUCT_XrDeviceAnchorPersistenceCreateInfoANDROID(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrPersistedAnchorSpaceCreateInfoANDROID, in order. +#define XR_LIST_STRUCT_XrPersistedAnchorSpaceCreateInfoANDROID(_) \ + _(type) \ + _(next) \ + _(anchorId) \ + +/// Calls your macro with the name of each member of XrPersistedAnchorSpaceInfoANDROID, in order. +#define XR_LIST_STRUCT_XrPersistedAnchorSpaceInfoANDROID(_) \ + _(type) \ + _(next) \ + _(anchor) \ + +/// Calls your macro with the name of each member of XrSystemDeviceAnchorPersistencePropertiesANDROID, in order. +#define XR_LIST_STRUCT_XrSystemDeviceAnchorPersistencePropertiesANDROID(_) \ + _(type) \ + _(next) \ + _(supportsAnchorPersistence) \ + +/// Calls your macro with the name of each member of XrFaceTrackerCreateInfoANDROID, in order. +#define XR_LIST_STRUCT_XrFaceTrackerCreateInfoANDROID(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrFaceStateGetInfoANDROID, in order. +#define XR_LIST_STRUCT_XrFaceStateGetInfoANDROID(_) \ + _(type) \ + _(next) \ + _(time) \ + +/// Calls your macro with the name of each member of XrFaceStateANDROID, in order. +#define XR_LIST_STRUCT_XrFaceStateANDROID(_) \ + _(type) \ + _(next) \ + _(parametersCapacityInput) \ + _(parametersCountOutput) \ + _(parameters) \ + _(faceTrackingState) \ + _(sampleTime) \ + _(isValid) \ + _(regionConfidencesCapacityInput) \ + _(regionConfidencesCountOutput) \ + _(regionConfidences) \ + +/// Calls your macro with the name of each member of XrSystemFaceTrackingPropertiesANDROID, in order. +#define XR_LIST_STRUCT_XrSystemFaceTrackingPropertiesANDROID(_) \ + _(type) \ + _(next) \ + _(supportsFaceTracking) \ + +/// Calls your macro with the name of each member of XrSystemPassthroughCameraStatePropertiesANDROID, in order. +#define XR_LIST_STRUCT_XrSystemPassthroughCameraStatePropertiesANDROID(_) \ + _(type) \ + _(next) \ + _(supportsPassthroughCameraState) \ + +/// Calls your macro with the name of each member of XrPassthroughCameraStateGetInfoANDROID, in order. +#define XR_LIST_STRUCT_XrPassthroughCameraStateGetInfoANDROID(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrEventDataRecommendedResolutionChangedANDROID, in order. +#define XR_LIST_STRUCT_XrEventDataRecommendedResolutionChangedANDROID(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrPassthroughLayerCreateInfoANDROID, in order. +#define XR_LIST_STRUCT_XrPassthroughLayerCreateInfoANDROID(_) \ + _(type) \ + _(next) \ + _(vertexCapacity) \ + _(indexCapacity) \ + +/// Calls your macro with the name of each member of XrPassthroughLayerMeshANDROID, in order. +#define XR_LIST_STRUCT_XrPassthroughLayerMeshANDROID(_) \ + _(type) \ + _(next) \ + _(windingOrder) \ + _(vertexCount) \ + _(vertices) \ + _(indexCount) \ + _(indices) \ + +/// Calls your macro with the name of each member of XrCompositionLayerPassthroughANDROID, in order. +#define XR_LIST_STRUCT_XrCompositionLayerPassthroughANDROID(_) \ + _(type) \ + _(next) \ + _(layerFlags) \ + _(space) \ + _(pose) \ + _(scale) \ + _(opacity) \ + _(layer) \ + +/// Calls your macro with the name of each member of XrSystemPassthroughLayerPropertiesANDROID, in order. +#define XR_LIST_STRUCT_XrSystemPassthroughLayerPropertiesANDROID(_) \ + _(type) \ + _(next) \ + _(supportsPassthroughLayer) \ + _(maxMeshIndexCount) \ + _(maxMeshVertexCount) \ + +/// Calls your macro with the name of each member of XrRaycastInfoANDROID, in order. +#define XR_LIST_STRUCT_XrRaycastInfoANDROID(_) \ + _(type) \ + _(next) \ + _(maxResults) \ + _(trackerCount) \ + _(trackers) \ + _(origin) \ + _(trajectory) \ + _(space) \ + _(time) \ + +/// Calls your macro with the name of each member of XrRaycastHitResultANDROID, in order. +#define XR_LIST_STRUCT_XrRaycastHitResultANDROID(_) \ + _(type) \ + _(trackable) \ + _(pose) \ + +/// Calls your macro with the name of each member of XrRaycastHitResultsANDROID, in order. +#define XR_LIST_STRUCT_XrRaycastHitResultsANDROID(_) \ + _(type) \ + _(next) \ + _(resultsCapacityInput) \ + _(resultsCountOutput) \ + _(results) \ + +/// Calls your macro with the name of each member of XrPerformanceMetricsStateANDROID, in order. +#define XR_LIST_STRUCT_XrPerformanceMetricsStateANDROID(_) \ + _(type) \ + _(next) \ + _(enabled) \ + +/// Calls your macro with the name of each member of XrPerformanceMetricsCounterANDROID, in order. +#define XR_LIST_STRUCT_XrPerformanceMetricsCounterANDROID(_) \ + _(type) \ + _(next) \ + _(counterFlags) \ + _(counterUnit) \ + _(uintValue) \ + _(floatValue) \ + +/// Calls your macro with the name of each member of XrTrackableObjectANDROID, in order. +#define XR_LIST_STRUCT_XrTrackableObjectANDROID(_) \ + _(type) \ + _(next) \ + _(trackingState) \ + _(centerPose) \ + _(extents) \ + _(objectLabel) \ + _(lastUpdatedTime) \ + +/// Calls your macro with the name of each member of XrTrackableObjectConfigurationANDROID, in order. +#define XR_LIST_STRUCT_XrTrackableObjectConfigurationANDROID(_) \ + _(type) \ + _(next) \ + _(labelCount) \ + _(activeLabels) \ + +/// Calls your macro with the name of each member of XrFutureCancelInfoEXT, in order. +#define XR_LIST_STRUCT_XrFutureCancelInfoEXT(_) \ + _(type) \ + _(next) \ + _(future) \ + +/// Calls your macro with the name of each member of XrFuturePollInfoEXT, in order. +#define XR_LIST_STRUCT_XrFuturePollInfoEXT(_) \ + _(type) \ + _(next) \ + _(future) \ + +/// Calls your macro with the name of each member of XrFutureCompletionBaseHeaderEXT, in order. +#define XR_LIST_STRUCT_XrFutureCompletionBaseHeaderEXT(_) \ + _(type) \ + _(next) \ + _(futureResult) \ + +/// Calls your macro with the name of each member of XrFuturePollResultEXT, in order. +#define XR_LIST_STRUCT_XrFuturePollResultEXT(_) \ + _(type) \ + _(next) \ + _(state) \ + +/// Calls your macro with the name of each member of XrEventDataUserPresenceChangedEXT, in order. +#define XR_LIST_STRUCT_XrEventDataUserPresenceChangedEXT(_) \ + _(type) \ + _(next) \ + _(session) \ + _(isUserPresent) \ + +/// Calls your macro with the name of each member of XrSystemUserPresencePropertiesEXT, in order. +#define XR_LIST_STRUCT_XrSystemUserPresencePropertiesEXT(_) \ + _(type) \ + _(next) \ + _(supportsUserPresence) \ + +/// Calls your macro with the name of each member of XrEventDataHeadsetFitChangedML, in order. +#define XR_LIST_STRUCT_XrEventDataHeadsetFitChangedML(_) \ + _(type) \ + _(next) \ + _(status) \ + _(time) \ + +/// Calls your macro with the name of each member of XrEventDataEyeCalibrationChangedML, in order. +#define XR_LIST_STRUCT_XrEventDataEyeCalibrationChangedML(_) \ + _(type) \ + _(next) \ + _(status) \ + +/// Calls your macro with the name of each member of XrUserCalibrationEnableEventsInfoML, in order. +#define XR_LIST_STRUCT_XrUserCalibrationEnableEventsInfoML(_) \ + _(type) \ + _(next) \ + _(enabled) \ + +/// Calls your macro with the name of each member of XrSystemNotificationsSetInfoML, in order. +#define XR_LIST_STRUCT_XrSystemNotificationsSetInfoML(_) \ + _(type) \ + _(next) \ + _(suppressNotifications) \ + +/// Calls your macro with the name of each member of XrWorldMeshDetectorCreateInfoML, in order. +#define XR_LIST_STRUCT_XrWorldMeshDetectorCreateInfoML(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrWorldMeshBlockStateML, in order. +#define XR_LIST_STRUCT_XrWorldMeshBlockStateML(_) \ + _(type) \ + _(next) \ + _(uuid) \ + _(meshBoundingBoxCenter) \ + _(meshBoundingBoxExtents) \ + _(lastUpdateTime) \ + _(status) \ + +/// Calls your macro with the name of each member of XrWorldMeshStateRequestInfoML, in order. +#define XR_LIST_STRUCT_XrWorldMeshStateRequestInfoML(_) \ + _(type) \ + _(next) \ + _(baseSpace) \ + _(time) \ + _(boundingBoxCenter) \ + _(boundingBoxExtents) \ + +/// Calls your macro with the name of each member of XrWorldMeshStateRequestCompletionML, in order. +#define XR_LIST_STRUCT_XrWorldMeshStateRequestCompletionML(_) \ + _(type) \ + _(next) \ + _(futureResult) \ + _(timestamp) \ + _(meshBlockStateCapacityInput) \ + _(meshBlockStateCountOutput) \ + _(meshBlockStates) \ + +/// Calls your macro with the name of each member of XrWorldMeshBufferRecommendedSizeInfoML, in order. +#define XR_LIST_STRUCT_XrWorldMeshBufferRecommendedSizeInfoML(_) \ + _(type) \ + _(next) \ + _(maxBlockCount) \ + +/// Calls your macro with the name of each member of XrWorldMeshBufferSizeML, in order. +#define XR_LIST_STRUCT_XrWorldMeshBufferSizeML(_) \ + _(type) \ + _(next) \ + _(size) \ + +/// Calls your macro with the name of each member of XrWorldMeshBufferML, in order. +#define XR_LIST_STRUCT_XrWorldMeshBufferML(_) \ + _(type) \ + _(next) \ + _(bufferSize) \ + _(buffer) \ + +/// Calls your macro with the name of each member of XrWorldMeshBlockRequestML, in order. +#define XR_LIST_STRUCT_XrWorldMeshBlockRequestML(_) \ + _(type) \ + _(next) \ + _(uuid) \ + _(lod) \ + +/// Calls your macro with the name of each member of XrWorldMeshGetInfoML, in order. +#define XR_LIST_STRUCT_XrWorldMeshGetInfoML(_) \ + _(type) \ + _(next) \ + _(flags) \ + _(fillHoleLength) \ + _(disconnectedComponentArea) \ + _(blockCount) \ + _(blocks) \ + +/// Calls your macro with the name of each member of XrWorldMeshBlockML, in order. +#define XR_LIST_STRUCT_XrWorldMeshBlockML(_) \ + _(type) \ + _(next) \ + _(uuid) \ + _(blockResult) \ + _(lod) \ + _(flags) \ + _(indexCount) \ + _(indexBuffer) \ + _(vertexCount) \ + _(vertexBuffer) \ + _(normalCount) \ + _(normalBuffer) \ + _(confidenceCount) \ + _(confidenceBuffer) \ + +/// Calls your macro with the name of each member of XrWorldMeshRequestCompletionInfoML, in order. +#define XR_LIST_STRUCT_XrWorldMeshRequestCompletionInfoML(_) \ + _(type) \ + _(next) \ + _(meshSpace) \ + _(meshSpaceLocateTime) \ + +/// Calls your macro with the name of each member of XrWorldMeshRequestCompletionML, in order. +#define XR_LIST_STRUCT_XrWorldMeshRequestCompletionML(_) \ + _(type) \ + _(next) \ + _(futureResult) \ + _(blockCount) \ + _(blocks) \ + +/// Calls your macro with the name of each member of XrSystemFacialExpressionPropertiesML, in order. +#define XR_LIST_STRUCT_XrSystemFacialExpressionPropertiesML(_) \ + _(type) \ + _(next) \ + _(supportsFacialExpression) \ + +/// Calls your macro with the name of each member of XrFacialExpressionClientCreateInfoML, in order. +#define XR_LIST_STRUCT_XrFacialExpressionClientCreateInfoML(_) \ + _(type) \ + _(next) \ + _(requestedCount) \ + _(requestedFacialBlendShapes) \ + +/// Calls your macro with the name of each member of XrFacialExpressionBlendShapeGetInfoML, in order. +#define XR_LIST_STRUCT_XrFacialExpressionBlendShapeGetInfoML(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrFacialExpressionBlendShapePropertiesML, in order. +#define XR_LIST_STRUCT_XrFacialExpressionBlendShapePropertiesML(_) \ + _(type) \ + _(next) \ + _(requestedFacialBlendShape) \ + _(weight) \ + _(flags) \ + _(time) \ + +/// Calls your macro with the name of each member of XrSystemBoundaryVisibilityPropertiesMETA, in order. +#define XR_LIST_STRUCT_XrSystemBoundaryVisibilityPropertiesMETA(_) \ + _(type) \ + _(next) \ + _(supportsBoundaryVisibility) \ + +/// Calls your macro with the name of each member of XrEventDataBoundaryVisibilityChangedMETA, in order. +#define XR_LIST_STRUCT_XrEventDataBoundaryVisibilityChangedMETA(_) \ + _(type) \ + _(next) \ + _(boundaryVisibility) \ + +/// Calls your macro with the name of each member of XrSystemSimultaneousHandsAndControllersPropertiesMETA, in order. +#define XR_LIST_STRUCT_XrSystemSimultaneousHandsAndControllersPropertiesMETA(_) \ + _(type) \ + _(next) \ + _(supportsSimultaneousHandsAndControllers) \ + +/// Calls your macro with the name of each member of XrSimultaneousHandsAndControllersTrackingResumeInfoMETA, in order. +#define XR_LIST_STRUCT_XrSimultaneousHandsAndControllersTrackingResumeInfoMETA(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSimultaneousHandsAndControllersTrackingPauseInfoMETA, in order. +#define XR_LIST_STRUCT_XrSimultaneousHandsAndControllersTrackingPauseInfoMETA(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrFaceTrackingVisemesMETA, in order. +#define XR_LIST_STRUCT_XrFaceTrackingVisemesMETA(_) \ + _(type) \ + _(next) \ + _(isValid) \ + _(visemes) \ + +/// Calls your macro with the name of each member of XrSystemFaceTrackingVisemesPropertiesMETA, in order. +#define XR_LIST_STRUCT_XrSystemFaceTrackingVisemesPropertiesMETA(_) \ + _(type) \ + _(next) \ + _(supportsVisemes) \ + +/// Calls your macro with the name of each member of XrRoomMeshFaceMETA, in order. +#define XR_LIST_STRUCT_XrRoomMeshFaceMETA(_) \ + _(uuid) \ + _(parentUuid) \ + _(semanticLabel) \ + +/// Calls your macro with the name of each member of XrRoomMeshFaceIndicesMETA, in order. +#define XR_LIST_STRUCT_XrRoomMeshFaceIndicesMETA(_) \ + _(type) \ + _(next) \ + _(indexCapacityInput) \ + _(indexCountOutput) \ + _(indices) \ + +/// Calls your macro with the name of each member of XrSpaceRoomMeshGetInfoMETA, in order. +#define XR_LIST_STRUCT_XrSpaceRoomMeshGetInfoMETA(_) \ + _(type) \ + _(next) \ + _(recognizedSemanticLabelCount) \ + _(recognizedSemanticLabels) \ + +/// Calls your macro with the name of each member of XrRoomMeshMETA, in order. +#define XR_LIST_STRUCT_XrRoomMeshMETA(_) \ + _(type) \ + _(next) \ + _(vertexCapacityInput) \ + _(vertexCountOutput) \ + _(vertices) \ + _(faceCapacityInput) \ + _(faceCountOutput) \ + _(faces) \ + +/// Calls your macro with the name of each member of XrColocationDiscoveryStartInfoMETA, in order. +#define XR_LIST_STRUCT_XrColocationDiscoveryStartInfoMETA(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrColocationDiscoveryStopInfoMETA, in order. +#define XR_LIST_STRUCT_XrColocationDiscoveryStopInfoMETA(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrColocationAdvertisementStartInfoMETA, in order. +#define XR_LIST_STRUCT_XrColocationAdvertisementStartInfoMETA(_) \ + _(type) \ + _(next) \ + _(bufferSize) \ + _(buffer) \ + +/// Calls your macro with the name of each member of XrColocationAdvertisementStopInfoMETA, in order. +#define XR_LIST_STRUCT_XrColocationAdvertisementStopInfoMETA(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrEventDataStartColocationAdvertisementCompleteMETA, in order. +#define XR_LIST_STRUCT_XrEventDataStartColocationAdvertisementCompleteMETA(_) \ + _(type) \ + _(next) \ + _(advertisementRequestId) \ + _(result) \ + _(advertisementUuid) \ + +/// Calls your macro with the name of each member of XrEventDataStopColocationAdvertisementCompleteMETA, in order. +#define XR_LIST_STRUCT_XrEventDataStopColocationAdvertisementCompleteMETA(_) \ + _(type) \ + _(next) \ + _(requestId) \ + _(result) \ + +/// Calls your macro with the name of each member of XrEventDataColocationAdvertisementCompleteMETA, in order. +#define XR_LIST_STRUCT_XrEventDataColocationAdvertisementCompleteMETA(_) \ + _(type) \ + _(next) \ + _(advertisementRequestId) \ + _(result) \ + +/// Calls your macro with the name of each member of XrEventDataStartColocationDiscoveryCompleteMETA, in order. +#define XR_LIST_STRUCT_XrEventDataStartColocationDiscoveryCompleteMETA(_) \ + _(type) \ + _(next) \ + _(discoveryRequestId) \ + _(result) \ + +/// Calls your macro with the name of each member of XrEventDataColocationDiscoveryResultMETA, in order. +#define XR_LIST_STRUCT_XrEventDataColocationDiscoveryResultMETA(_) \ + _(type) \ + _(next) \ + _(discoveryRequestId) \ + _(advertisementUuid) \ + _(bufferSize) \ + _(buffer) \ + +/// Calls your macro with the name of each member of XrEventDataColocationDiscoveryCompleteMETA, in order. +#define XR_LIST_STRUCT_XrEventDataColocationDiscoveryCompleteMETA(_) \ + _(type) \ + _(next) \ + _(discoveryRequestId) \ + _(result) \ + +/// Calls your macro with the name of each member of XrEventDataStopColocationDiscoveryCompleteMETA, in order. +#define XR_LIST_STRUCT_XrEventDataStopColocationDiscoveryCompleteMETA(_) \ + _(type) \ + _(next) \ + _(requestId) \ + _(result) \ + +/// Calls your macro with the name of each member of XrSystemColocationDiscoveryPropertiesMETA, in order. +#define XR_LIST_STRUCT_XrSystemColocationDiscoveryPropertiesMETA(_) \ + _(type) \ + _(next) \ + _(supportsColocationDiscovery) \ + +/// Calls your macro with the name of each member of XrSystemSpatialEntityGroupSharingPropertiesMETA, in order. +#define XR_LIST_STRUCT_XrSystemSpatialEntityGroupSharingPropertiesMETA(_) \ + _(type) \ + _(next) \ + _(supportsSpatialEntityGroupSharing) \ + +/// Calls your macro with the name of each member of XrShareSpacesRecipientGroupsMETA, in order. +#define XR_LIST_STRUCT_XrShareSpacesRecipientGroupsMETA(_) \ + _(type) \ + _(next) \ + _(groupCount) \ + _(groups) \ + +/// Calls your macro with the name of each member of XrSpaceGroupUuidFilterInfoMETA, in order. +#define XR_LIST_STRUCT_XrSpaceGroupUuidFilterInfoMETA(_) \ + _(type) \ + _(next) \ + _(groupUuid) \ + +/// Calls your macro with the name of each member of XrSystemEnvironmentRaycastPropertiesMETA, in order. +#define XR_LIST_STRUCT_XrSystemEnvironmentRaycastPropertiesMETA(_) \ + _(type) \ + _(next) \ + _(supportsEnvironmentRaycast) \ + +/// Calls your macro with the name of each member of XrEnvironmentRaycasterCreateInfoMETA, in order. +#define XR_LIST_STRUCT_XrEnvironmentRaycasterCreateInfoMETA(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrEnvironmentRaycasterCreateCompletionMETA, in order. +#define XR_LIST_STRUCT_XrEnvironmentRaycasterCreateCompletionMETA(_) \ + _(type) \ + _(next) \ + _(futureResult) \ + _(environmentRaycaster) \ + +/// Calls your macro with the name of each member of XrEnvironmentRaycastFilterBaseHeaderMETA, in order. +#define XR_LIST_STRUCT_XrEnvironmentRaycastFilterBaseHeaderMETA(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrEnvironmentRaycastHitGetInfoMETA, in order. +#define XR_LIST_STRUCT_XrEnvironmentRaycastHitGetInfoMETA(_) \ + _(type) \ + _(next) \ + _(baseSpace) \ + _(time) \ + _(origin) \ + _(direction) \ + _(filterCount) \ + _(filters) \ + +/// Calls your macro with the name of each member of XrEnvironmentRaycastHitMETA, in order. +#define XR_LIST_STRUCT_XrEnvironmentRaycastHitMETA(_) \ + _(type) \ + _(next) \ + _(status) \ + _(pose) \ + +/// Calls your macro with the name of each member of XrEnvironmentRaycastFilterDistanceMETA, in order. +#define XR_LIST_STRUCT_XrEnvironmentRaycastFilterDistanceMETA(_) \ + _(type) \ + _(next) \ + _(maxDistance) \ + +/// Calls your macro with the name of each member of XrExtent3DiMETA, in order. +#define XR_LIST_STRUCT_XrExtent3DiMETA(_) \ + _(width) \ + _(height) \ + _(depth) \ + +/// Calls your macro with the name of each member of XrTilePropertiesMETA, in order. +#define XR_LIST_STRUCT_XrTilePropertiesMETA(_) \ + _(type) \ + _(next) \ + _(tileDimensions) \ + _(apronDimensions) \ + _(origin) \ + +/// Calls your macro with the name of each member of XrTilePropertiesHintMETA, in order. +#define XR_LIST_STRUCT_XrTilePropertiesHintMETA(_) \ + _(type) \ + _(next) \ + _(propertiesCount) \ + _(properties) \ + +/// Calls your macro with the name of each member of XrHandTrackingUnextrapolatedPosesRequestMETA, in order. +#define XR_LIST_STRUCT_XrHandTrackingUnextrapolatedPosesRequestMETA(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrHandTrackingUnextrapolatedPosesMETA, in order. +#define XR_LIST_STRUCT_XrHandTrackingUnextrapolatedPosesMETA(_) \ + _(type) \ + _(next) \ + _(captureTime) \ + +/// Calls your macro with the name of each member of XrSystemLightEstimationPropertiesANDROID, in order. +#define XR_LIST_STRUCT_XrSystemLightEstimationPropertiesANDROID(_) \ + _(type) \ + _(next) \ + _(supportsLightEstimation) \ + +/// Calls your macro with the name of each member of XrLightEstimatorCreateInfoANDROID, in order. +#define XR_LIST_STRUCT_XrLightEstimatorCreateInfoANDROID(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrLightEstimateGetInfoANDROID, in order. +#define XR_LIST_STRUCT_XrLightEstimateGetInfoANDROID(_) \ + _(type) \ + _(next) \ + _(space) \ + _(time) \ + +/// Calls your macro with the name of each member of XrLightEstimateANDROID, in order. +#define XR_LIST_STRUCT_XrLightEstimateANDROID(_) \ + _(type) \ + _(next) \ + _(state) \ + _(lastUpdatedTime) \ + +/// Calls your macro with the name of each member of XrDirectionalLightANDROID, in order. +#define XR_LIST_STRUCT_XrDirectionalLightANDROID(_) \ + _(type) \ + _(next) \ + _(state) \ + _(intensity) \ + _(direction) \ + +/// Calls your macro with the name of each member of XrAmbientLightANDROID, in order. +#define XR_LIST_STRUCT_XrAmbientLightANDROID(_) \ + _(type) \ + _(next) \ + _(state) \ + _(intensity) \ + _(colorCorrection) \ + +/// Calls your macro with the name of each member of XrSphericalHarmonicsANDROID, in order. +#define XR_LIST_STRUCT_XrSphericalHarmonicsANDROID(_) \ + _(type) \ + _(next) \ + _(state) \ + _(kind) \ + _(coefficients) \ + +/// Calls your macro with the name of each member of XrAnchorSharingInfoANDROID, in order. +#define XR_LIST_STRUCT_XrAnchorSharingInfoANDROID(_) \ + _(type) \ + _(next) \ + _(anchor) \ + +/// Calls your macro with the name of each member of XrAnchorSharingTokenANDROID, in order. +#define XR_LIST_STRUCT_XrAnchorSharingTokenANDROID(_) \ + _(type) \ + _(next) \ + _(token) \ + +/// Calls your macro with the name of each member of XrSystemAnchorSharingExportPropertiesANDROID, in order. +#define XR_LIST_STRUCT_XrSystemAnchorSharingExportPropertiesANDROID(_) \ + _(type) \ + _(next) \ + _(supportsAnchorSharingExport) \ + +/// Calls your macro with the name of each member of XrSystemMarkerTrackingPropertiesANDROID, in order. +#define XR_LIST_STRUCT_XrSystemMarkerTrackingPropertiesANDROID(_) \ + _(type) \ + _(next) \ + _(supportsMarkerTracking) \ + _(supportsMarkerSizeEstimation) \ + _(maxMarkerCount) \ + +/// Calls your macro with the name of each member of XrTrackableMarkerDatabaseEntryANDROID, in order. +#define XR_LIST_STRUCT_XrTrackableMarkerDatabaseEntryANDROID(_) \ + _(id) \ + _(edgeSize) \ + +/// Calls your macro with the name of each member of XrTrackableMarkerDatabaseANDROID, in order. +#define XR_LIST_STRUCT_XrTrackableMarkerDatabaseANDROID(_) \ + _(dictionary) \ + _(entryCount) \ + _(entries) \ + +/// Calls your macro with the name of each member of XrTrackableMarkerConfigurationANDROID, in order. +#define XR_LIST_STRUCT_XrTrackableMarkerConfigurationANDROID(_) \ + _(type) \ + _(next) \ + _(trackingMode) \ + _(databaseCount) \ + _(databases) \ + +/// Calls your macro with the name of each member of XrTrackableMarkerANDROID, in order. +#define XR_LIST_STRUCT_XrTrackableMarkerANDROID(_) \ + _(type) \ + _(next) \ + _(trackingState) \ + _(lastUpdatedTime) \ + _(dictionary) \ + _(markerId) \ + _(centerPose) \ + _(extents) \ + +/// Calls your macro with the name of each member of XrSystemQrCodeTrackingPropertiesANDROID, in order. +#define XR_LIST_STRUCT_XrSystemQrCodeTrackingPropertiesANDROID(_) \ + _(type) \ + _(next) \ + _(supportsQrCodeTracking) \ + _(supportsQrCodeSizeEstimation) \ + _(maxQrCodeCount) \ + +/// Calls your macro with the name of each member of XrTrackableQrCodeConfigurationANDROID, in order. +#define XR_LIST_STRUCT_XrTrackableQrCodeConfigurationANDROID(_) \ + _(type) \ + _(next) \ + _(trackingMode) \ + _(qrCodeEdgeSize) \ + +/// Calls your macro with the name of each member of XrTrackableQrCodeANDROID, in order. +#define XR_LIST_STRUCT_XrTrackableQrCodeANDROID(_) \ + _(type) \ + _(next) \ + _(trackingState) \ + _(lastUpdatedTime) \ + _(centerPose) \ + _(extents) \ + _(bufferCapacityInput) \ + _(bufferCountOutput) \ + _(buffer) \ + +/// Calls your macro with the name of each member of XrSystemImageTrackingPropertiesANDROID, in order. +#define XR_LIST_STRUCT_XrSystemImageTrackingPropertiesANDROID(_) \ + _(type) \ + _(next) \ + _(supportsImageTracking) \ + _(supportsPhysicalSizeEstimation) \ + _(maxTrackedImageCount) \ + _(maxLoadedImageCount) \ + +/// Calls your macro with the name of each member of XrTrackableImageDatabaseEntryANDROID, in order. +#define XR_LIST_STRUCT_XrTrackableImageDatabaseEntryANDROID(_) \ + _(type) \ + _(next) \ + _(trackingMode) \ + _(physicalWidth) \ + _(imageWidth) \ + _(imageHeight) \ + _(format) \ + _(bufferSize) \ + _(buffer) \ + +/// Calls your macro with the name of each member of XrTrackableImageDatabaseCreateInfoANDROID, in order. +#define XR_LIST_STRUCT_XrTrackableImageDatabaseCreateInfoANDROID(_) \ + _(type) \ + _(next) \ + _(entryCount) \ + _(entries) \ + +/// Calls your macro with the name of each member of XrCreateTrackableImageDatabaseCompletionANDROID, in order. +#define XR_LIST_STRUCT_XrCreateTrackableImageDatabaseCompletionANDROID(_) \ + _(type) \ + _(next) \ + _(futureResult) \ + _(database) \ + +/// Calls your macro with the name of each member of XrTrackableImageConfigurationANDROID, in order. +#define XR_LIST_STRUCT_XrTrackableImageConfigurationANDROID(_) \ + _(type) \ + _(next) \ + _(databaseCount) \ + _(databases) \ + +/// Calls your macro with the name of each member of XrTrackableImageANDROID, in order. +#define XR_LIST_STRUCT_XrTrackableImageANDROID(_) \ + _(type) \ + _(next) \ + _(trackingState) \ + _(lastUpdatedTime) \ + _(database) \ + _(databaseEntryIndex) \ + _(centerPose) \ + _(extents) \ + +/// Calls your macro with the name of each member of XrEventDataImageTrackingLostANDROID, in order. +#define XR_LIST_STRUCT_XrEventDataImageTrackingLostANDROID(_) \ + _(type) \ + _(next) \ + _(time) \ + +/// Calls your macro with the name of each member of XrSystemSceneMeshingPropertiesANDROID, in order. +#define XR_LIST_STRUCT_XrSystemSceneMeshingPropertiesANDROID(_) \ + _(type) \ + _(next) \ + _(supportsSceneMeshing) \ + +/// Calls your macro with the name of each member of XrSceneMeshingTrackerCreateInfoANDROID, in order. +#define XR_LIST_STRUCT_XrSceneMeshingTrackerCreateInfoANDROID(_) \ + _(type) \ + _(next) \ + _(semanticLabelSet) \ + _(enableNormals) \ + +/// Calls your macro with the name of each member of XrSceneMeshSnapshotCreateInfoANDROID, in order. +#define XR_LIST_STRUCT_XrSceneMeshSnapshotCreateInfoANDROID(_) \ + _(type) \ + _(next) \ + _(baseSpace) \ + _(time) \ + _(boundingBox) \ + +/// Calls your macro with the name of each member of XrSceneMeshSnapshotCreationResultANDROID, in order. +#define XR_LIST_STRUCT_XrSceneMeshSnapshotCreationResultANDROID(_) \ + _(type) \ + _(next) \ + _(snapshot) \ + _(trackingState) \ + +/// Calls your macro with the name of each member of XrSceneSubmeshStateANDROID, in order. +#define XR_LIST_STRUCT_XrSceneSubmeshStateANDROID(_) \ + _(type) \ + _(next) \ + _(submeshId) \ + _(lastUpdatedTime) \ + _(submeshPoseInBaseSpace) \ + _(bounds) \ + +/// Calls your macro with the name of each member of XrSceneSubmeshDataANDROID, in order. +#define XR_LIST_STRUCT_XrSceneSubmeshDataANDROID(_) \ + _(type) \ + _(next) \ + _(submeshId) \ + _(vertexCapacityInput) \ + _(vertexCountOutput) \ + _(vertexPositions) \ + _(vertexNormals) \ + _(vertexSemantics) \ + _(indexCapacityInput) \ + _(indexCountOutput) \ + _(indices) \ + +/// Calls your macro with the name of each member of XrSpatialCapabilityComponentTypesEXT, in order. +#define XR_LIST_STRUCT_XrSpatialCapabilityComponentTypesEXT(_) \ + _(type) \ + _(next) \ + _(componentTypeCapacityInput) \ + _(componentTypeCountOutput) \ + _(componentTypes) \ + +/// Calls your macro with the name of each member of XrSpatialCapabilityConfigurationBaseHeaderEXT, in order. +#define XR_LIST_STRUCT_XrSpatialCapabilityConfigurationBaseHeaderEXT(_) \ + _(type) \ + _(next) \ + _(capability) \ + _(enabledComponentCount) \ + _(enabledComponents) \ + +/// Calls your macro with the name of each member of XrSpatialContextCreateInfoEXT, in order. +#define XR_LIST_STRUCT_XrSpatialContextCreateInfoEXT(_) \ + _(type) \ + _(next) \ + _(capabilityConfigCount) \ + _(capabilityConfigs) \ + +/// Calls your macro with the name of each member of XrCreateSpatialContextCompletionEXT, in order. +#define XR_LIST_STRUCT_XrCreateSpatialContextCompletionEXT(_) \ + _(type) \ + _(next) \ + _(futureResult) \ + _(spatialContext) \ + +/// Calls your macro with the name of each member of XrSpatialDiscoverySnapshotCreateInfoEXT, in order. +#define XR_LIST_STRUCT_XrSpatialDiscoverySnapshotCreateInfoEXT(_) \ + _(type) \ + _(next) \ + _(componentTypeCount) \ + _(componentTypes) \ + +/// Calls your macro with the name of each member of XrCreateSpatialDiscoverySnapshotCompletionInfoEXT, in order. +#define XR_LIST_STRUCT_XrCreateSpatialDiscoverySnapshotCompletionInfoEXT(_) \ + _(type) \ + _(next) \ + _(baseSpace) \ + _(time) \ + _(future) \ + +/// Calls your macro with the name of each member of XrCreateSpatialDiscoverySnapshotCompletionEXT, in order. +#define XR_LIST_STRUCT_XrCreateSpatialDiscoverySnapshotCompletionEXT(_) \ + _(type) \ + _(next) \ + _(futureResult) \ + _(snapshot) \ + +/// Calls your macro with the name of each member of XrSpatialComponentDataQueryConditionEXT, in order. +#define XR_LIST_STRUCT_XrSpatialComponentDataQueryConditionEXT(_) \ + _(type) \ + _(next) \ + _(componentTypeCount) \ + _(componentTypes) \ + +/// Calls your macro with the name of each member of XrSpatialComponentDataQueryResultEXT, in order. +#define XR_LIST_STRUCT_XrSpatialComponentDataQueryResultEXT(_) \ + _(type) \ + _(next) \ + _(entityIdCapacityInput) \ + _(entityIdCountOutput) \ + _(entityIds) \ + _(entityStateCapacityInput) \ + _(entityStateCountOutput) \ + _(entityStates) \ + +/// Calls your macro with the name of each member of XrSpatialBufferEXT, in order. +#define XR_LIST_STRUCT_XrSpatialBufferEXT(_) \ + _(bufferId) \ + _(bufferType) \ + +/// Calls your macro with the name of each member of XrSpatialBufferGetInfoEXT, in order. +#define XR_LIST_STRUCT_XrSpatialBufferGetInfoEXT(_) \ + _(type) \ + _(next) \ + _(bufferId) \ + +/// Calls your macro with the name of each member of XrSpatialBounded2DDataEXT, in order. +#define XR_LIST_STRUCT_XrSpatialBounded2DDataEXT(_) \ + _(center) \ + _(extents) \ + +/// Calls your macro with the name of each member of XrSpatialComponentBounded2DListEXT, in order. +#define XR_LIST_STRUCT_XrSpatialComponentBounded2DListEXT(_) \ + _(type) \ + _(next) \ + _(boundCount) \ + _(bounds) \ + +/// Calls your macro with the name of each member of XrSpatialComponentBounded3DListEXT, in order. +#define XR_LIST_STRUCT_XrSpatialComponentBounded3DListEXT(_) \ + _(type) \ + _(next) \ + _(boundCount) \ + _(bounds) \ + +/// Calls your macro with the name of each member of XrSpatialComponentParentListEXT, in order. +#define XR_LIST_STRUCT_XrSpatialComponentParentListEXT(_) \ + _(type) \ + _(next) \ + _(parentCount) \ + _(parents) \ + +/// Calls your macro with the name of each member of XrSpatialMeshDataEXT, in order. +#define XR_LIST_STRUCT_XrSpatialMeshDataEXT(_) \ + _(origin) \ + _(vertexBuffer) \ + _(indexBuffer) \ + +/// Calls your macro with the name of each member of XrSpatialComponentMesh3DListEXT, in order. +#define XR_LIST_STRUCT_XrSpatialComponentMesh3DListEXT(_) \ + _(type) \ + _(next) \ + _(meshCount) \ + _(meshes) \ + +/// Calls your macro with the name of each member of XrSpatialEntityFromIdCreateInfoEXT, in order. +#define XR_LIST_STRUCT_XrSpatialEntityFromIdCreateInfoEXT(_) \ + _(type) \ + _(next) \ + _(entityId) \ + +/// Calls your macro with the name of each member of XrSpatialUpdateSnapshotCreateInfoEXT, in order. +#define XR_LIST_STRUCT_XrSpatialUpdateSnapshotCreateInfoEXT(_) \ + _(type) \ + _(next) \ + _(entityCount) \ + _(entities) \ + _(componentTypeCount) \ + _(componentTypes) \ + _(baseSpace) \ + _(time) \ + +/// Calls your macro with the name of each member of XrEventDataSpatialDiscoveryRecommendedEXT, in order. +#define XR_LIST_STRUCT_XrEventDataSpatialDiscoveryRecommendedEXT(_) \ + _(type) \ + _(next) \ + _(spatialContext) \ + +/// Calls your macro with the name of each member of XrSpatialFilterTrackingStateEXT, in order. +#define XR_LIST_STRUCT_XrSpatialFilterTrackingStateEXT(_) \ + _(type) \ + _(next) \ + _(trackingState) \ + +/// Calls your macro with the name of each member of XrSpatialCapabilityConfigurationPlaneTrackingEXT, in order. +#define XR_LIST_STRUCT_XrSpatialCapabilityConfigurationPlaneTrackingEXT(_) \ + _(type) \ + _(next) \ + _(capability) \ + _(enabledComponentCount) \ + _(enabledComponents) \ + +/// Calls your macro with the name of each member of XrSpatialComponentPlaneAlignmentListEXT, in order. +#define XR_LIST_STRUCT_XrSpatialComponentPlaneAlignmentListEXT(_) \ + _(type) \ + _(next) \ + _(planeAlignmentCount) \ + _(planeAlignments) \ + +/// Calls your macro with the name of each member of XrSpatialComponentMesh2DListEXT, in order. +#define XR_LIST_STRUCT_XrSpatialComponentMesh2DListEXT(_) \ + _(type) \ + _(next) \ + _(meshCount) \ + _(meshes) \ + +/// Calls your macro with the name of each member of XrSpatialPolygon2DDataEXT, in order. +#define XR_LIST_STRUCT_XrSpatialPolygon2DDataEXT(_) \ + _(origin) \ + _(vertexBuffer) \ + +/// Calls your macro with the name of each member of XrSpatialComponentPolygon2DListEXT, in order. +#define XR_LIST_STRUCT_XrSpatialComponentPolygon2DListEXT(_) \ + _(type) \ + _(next) \ + _(polygonCount) \ + _(polygons) \ + +/// Calls your macro with the name of each member of XrSpatialComponentPlaneSemanticLabelListEXT, in order. +#define XR_LIST_STRUCT_XrSpatialComponentPlaneSemanticLabelListEXT(_) \ + _(type) \ + _(next) \ + _(semanticLabelCount) \ + _(semanticLabels) \ + +/// Calls your macro with the name of each member of XrStationaryReferenceSpaceGenerationIdGetInfoEXT, in order. +#define XR_LIST_STRUCT_XrStationaryReferenceSpaceGenerationIdGetInfoEXT(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrStationaryReferenceSpaceGenerationIdResultEXT, in order. +#define XR_LIST_STRUCT_XrStationaryReferenceSpaceGenerationIdResultEXT(_) \ + _(type) \ + _(next) \ + _(generationId) \ + +/// Calls your macro with the name of each member of XrSpatialCapabilityConfigurationQrCodeEXT, in order. +#define XR_LIST_STRUCT_XrSpatialCapabilityConfigurationQrCodeEXT(_) \ + _(type) \ + _(next) \ + _(capability) \ + _(enabledComponentCount) \ + _(enabledComponents) \ + +/// Calls your macro with the name of each member of XrSpatialCapabilityConfigurationMicroQrCodeEXT, in order. +#define XR_LIST_STRUCT_XrSpatialCapabilityConfigurationMicroQrCodeEXT(_) \ + _(type) \ + _(next) \ + _(capability) \ + _(enabledComponentCount) \ + _(enabledComponents) \ + +/// Calls your macro with the name of each member of XrSpatialCapabilityConfigurationArucoMarkerEXT, in order. +#define XR_LIST_STRUCT_XrSpatialCapabilityConfigurationArucoMarkerEXT(_) \ + _(type) \ + _(next) \ + _(capability) \ + _(enabledComponentCount) \ + _(enabledComponents) \ + _(arUcoDict) \ + +/// Calls your macro with the name of each member of XrSpatialCapabilityConfigurationAprilTagEXT, in order. +#define XR_LIST_STRUCT_XrSpatialCapabilityConfigurationAprilTagEXT(_) \ + _(type) \ + _(next) \ + _(capability) \ + _(enabledComponentCount) \ + _(enabledComponents) \ + _(aprilDict) \ + +/// Calls your macro with the name of each member of XrSpatialMarkerSizeEXT, in order. +#define XR_LIST_STRUCT_XrSpatialMarkerSizeEXT(_) \ + _(type) \ + _(next) \ + _(markerSideLength) \ + +/// Calls your macro with the name of each member of XrSpatialMarkerStaticOptimizationEXT, in order. +#define XR_LIST_STRUCT_XrSpatialMarkerStaticOptimizationEXT(_) \ + _(type) \ + _(next) \ + _(optimizeForStaticMarker) \ + +/// Calls your macro with the name of each member of XrSpatialMarkerDataEXT, in order. +#define XR_LIST_STRUCT_XrSpatialMarkerDataEXT(_) \ + _(capability) \ + _(markerId) \ + _(data) \ + +/// Calls your macro with the name of each member of XrSpatialComponentMarkerListEXT, in order. +#define XR_LIST_STRUCT_XrSpatialComponentMarkerListEXT(_) \ + _(type) \ + _(next) \ + _(markerCount) \ + _(markers) \ + +/// Calls your macro with the name of each member of XrSystemDynamicObjectTrackingPropertiesBD, in order. +#define XR_LIST_STRUCT_XrSystemDynamicObjectTrackingPropertiesBD(_) \ + _(type) \ + _(next) \ + _(supportsDynamicObjectTracking) \ + +/// Calls your macro with the name of each member of XrSenseDataProviderCreateInfoDynamicObjectBD, in order. +#define XR_LIST_STRUCT_XrSenseDataProviderCreateInfoDynamicObjectBD(_) \ + _(type) \ + _(next) \ + _(trackingTypeCount) \ + _(trackingTypes) \ + +/// Calls your macro with the name of each member of XrDynamicObjectDataBD, in order. +#define XR_LIST_STRUCT_XrDynamicObjectDataBD(_) \ + _(type) \ + _(next) \ + _(objectType) \ + +/// Calls your macro with the name of each member of XrSpatialEntityComponentDataDynamicObjectBD, in order. +#define XR_LIST_STRUCT_XrSpatialEntityComponentDataDynamicObjectBD(_) \ + _(type) \ + _(next) \ + _(data) \ + +/// Calls your macro with the name of each member of XrSenseDataFilterDynamicObjectTypeBD, in order. +#define XR_LIST_STRUCT_XrSenseDataFilterDynamicObjectTypeBD(_) \ + _(type) \ + _(next) \ + _(typeCount) \ + _(types) \ + +/// Calls your macro with the name of each member of XrSystemDynamicObjectKeyboardPropertiesBD, in order. +#define XR_LIST_STRUCT_XrSystemDynamicObjectKeyboardPropertiesBD(_) \ + _(type) \ + _(next) \ + _(supportsDynamicObjectKeyboard) \ + +/// Calls your macro with the name of each member of XrSystemDynamicObjectMousePropertiesBD, in order. +#define XR_LIST_STRUCT_XrSystemDynamicObjectMousePropertiesBD(_) \ + _(type) \ + _(next) \ + _(supportsDynamicObjectMouse) \ + +/// Calls your macro with the name of each member of XrCameraPropertyBaseHeaderBD, in order. +#define XR_LIST_STRUCT_XrCameraPropertyBaseHeaderBD(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrCameraPropertiesBD, in order. +#define XR_LIST_STRUCT_XrCameraPropertiesBD(_) \ + _(type) \ + _(next) \ + _(propertyCount) \ + _(properties) \ + +/// Calls your macro with the name of each member of XrCameraCapabilityBaseHeaderBD, in order. +#define XR_LIST_STRUCT_XrCameraCapabilityBaseHeaderBD(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrCameraCapabilitiesBD, in order. +#define XR_LIST_STRUCT_XrCameraCapabilitiesBD(_) \ + _(type) \ + _(next) \ + _(capabilityCount) \ + _(capabilities) \ + +/// Calls your macro with the name of each member of XrAvailableCamerasEnumerateInfoBD, in order. +#define XR_LIST_STRUCT_XrAvailableCamerasEnumerateInfoBD(_) \ + _(type) \ + _(next) \ + _(properties) \ + _(capabilities) \ + +/// Calls your macro with the name of each member of XrAvailableCameraBD, in order. +#define XR_LIST_STRUCT_XrAvailableCameraBD(_) \ + _(type) \ + _(next) \ + _(cameraId) \ + +/// Calls your macro with the name of each member of XrCameraPropertyTypesEnumerateInfoBD, in order. +#define XR_LIST_STRUCT_XrCameraPropertyTypesEnumerateInfoBD(_) \ + _(type) \ + _(next) \ + _(cameraId) \ + +/// Calls your macro with the name of each member of XrCameraPropertyTypesBD, in order. +#define XR_LIST_STRUCT_XrCameraPropertyTypesBD(_) \ + _(type) \ + _(next) \ + _(propertyTypeCapacityInput) \ + _(propertyTypeCountOutput) \ + _(propertyTypes) \ + +/// Calls your macro with the name of each member of XrCameraPropertiesGetInfoBD, in order. +#define XR_LIST_STRUCT_XrCameraPropertiesGetInfoBD(_) \ + _(type) \ + _(next) \ + _(cameraId) \ + +/// Calls your macro with the name of each member of XrCameraPropertyFacingBD, in order. +#define XR_LIST_STRUCT_XrCameraPropertyFacingBD(_) \ + _(type) \ + _(next) \ + _(facing) \ + +/// Calls your macro with the name of each member of XrCameraPropertyPositionBD, in order. +#define XR_LIST_STRUCT_XrCameraPropertyPositionBD(_) \ + _(type) \ + _(next) \ + _(position) \ + +/// Calls your macro with the name of each member of XrCameraPropertyCameraTypeBD, in order. +#define XR_LIST_STRUCT_XrCameraPropertyCameraTypeBD(_) \ + _(type) \ + _(next) \ + _(cameraType) \ + +/// Calls your macro with the name of each member of XrCameraCapabilityTypesEnumerateInfoBD, in order. +#define XR_LIST_STRUCT_XrCameraCapabilityTypesEnumerateInfoBD(_) \ + _(type) \ + _(next) \ + _(cameraId) \ + +/// Calls your macro with the name of each member of XrCameraCapabilityTypesBD, in order. +#define XR_LIST_STRUCT_XrCameraCapabilityTypesBD(_) \ + _(type) \ + _(next) \ + _(capabilityTypeCapacityInput) \ + _(capabilityTypeCountOutput) \ + _(capabilityTypes) \ + +/// Calls your macro with the name of each member of XrCameraSupportedCapabilitiesGetInfoBD, in order. +#define XR_LIST_STRUCT_XrCameraSupportedCapabilitiesGetInfoBD(_) \ + _(type) \ + _(next) \ + _(id) \ + +/// Calls your macro with the name of each member of XrCameraSupportedCapabilityBaseHeaderBD, in order. +#define XR_LIST_STRUCT_XrCameraSupportedCapabilityBaseHeaderBD(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrCameraSupportedCapabilitiesBD, in order. +#define XR_LIST_STRUCT_XrCameraSupportedCapabilitiesBD(_) \ + _(type) \ + _(next) \ + _(capabilityCount) \ + _(capabilities) \ + +/// Calls your macro with the name of each member of XrCameraImageResolutionAndFrameRateBD, in order. +#define XR_LIST_STRUCT_XrCameraImageResolutionAndFrameRateBD(_) \ + _(resolution) \ + _(frameRate) \ + +/// Calls your macro with the name of each member of XrCameraSupportedCapabilityImageResolutionAndFrameRateBD, in order. +#define XR_LIST_STRUCT_XrCameraSupportedCapabilityImageResolutionAndFrameRateBD(_) \ + _(type) \ + _(next) \ + _(resolutionAndFrameRateCapacityInput) \ + _(resolutionAndFrameRateCountOutput) \ + _(resolutionAndFrameRates) \ + +/// Calls your macro with the name of each member of XrCameraCapabilityImageResolutionAndFrameRateBD, in order. +#define XR_LIST_STRUCT_XrCameraCapabilityImageResolutionAndFrameRateBD(_) \ + _(type) \ + _(next) \ + _(resolution) \ + _(frameRate) \ + +/// Calls your macro with the name of each member of XrCameraSupportedCapabilityDataTransferTypeBD, in order. +#define XR_LIST_STRUCT_XrCameraSupportedCapabilityDataTransferTypeBD(_) \ + _(type) \ + _(next) \ + _(transferTypeCapacityInput) \ + _(transferTypeCountOutput) \ + _(transferTypes) \ + +/// Calls your macro with the name of each member of XrCameraCapabilityDataTransferTypeBD, in order. +#define XR_LIST_STRUCT_XrCameraCapabilityDataTransferTypeBD(_) \ + _(type) \ + _(next) \ + _(transferType) \ + +/// Calls your macro with the name of each member of XrCameraSupportedCapabilityImageFormatBD, in order. +#define XR_LIST_STRUCT_XrCameraSupportedCapabilityImageFormatBD(_) \ + _(type) \ + _(next) \ + _(formatCapacityInput) \ + _(formatCountOutput) \ + _(formats) \ + +/// Calls your macro with the name of each member of XrCameraCapabilityImageFormatBD, in order. +#define XR_LIST_STRUCT_XrCameraCapabilityImageFormatBD(_) \ + _(type) \ + _(next) \ + _(format) \ + +/// Calls your macro with the name of each member of XrCameraSupportedCapabilityCameraModelBD, in order. +#define XR_LIST_STRUCT_XrCameraSupportedCapabilityCameraModelBD(_) \ + _(type) \ + _(next) \ + _(modelCapacityInput) \ + _(modelCountOutput) \ + _(models) \ + +/// Calls your macro with the name of each member of XrCameraCapabilityCameraModelBD, in order. +#define XR_LIST_STRUCT_XrCameraCapabilityCameraModelBD(_) \ + _(type) \ + _(next) \ + _(model) \ + +/// Calls your macro with the name of each member of XrCameraDeviceCreateInfoBD, in order. +#define XR_LIST_STRUCT_XrCameraDeviceCreateInfoBD(_) \ + _(type) \ + _(next) \ + _(cameraId) \ + +/// Calls your macro with the name of each member of XrCreateCameraDeviceCompletionBD, in order. +#define XR_LIST_STRUCT_XrCreateCameraDeviceCompletionBD(_) \ + _(type) \ + _(next) \ + _(futureResult) \ + _(device) \ + +/// Calls your macro with the name of each member of XrCameraCaptureSessionCreateInfoBD, in order. +#define XR_LIST_STRUCT_XrCameraCaptureSessionCreateInfoBD(_) \ + _(type) \ + _(next) \ + _(camera) \ + _(configCount) \ + _(configs) \ + +/// Calls your macro with the name of each member of XrCreateCameraCaptureSessionCompletionBD, in order. +#define XR_LIST_STRUCT_XrCreateCameraCaptureSessionCompletionBD(_) \ + _(type) \ + _(next) \ + _(futureResult) \ + _(captureSession) \ + +/// Calls your macro with the name of each member of XrCameraIntrinsicsBD, in order. +#define XR_LIST_STRUCT_XrCameraIntrinsicsBD(_) \ + _(type) \ + _(next) \ + _(focalLength) \ + _(principalPoint) \ + _(fov) \ + +/// Calls your macro with the name of each member of XrCameraExtrinsicsBD, in order. +#define XR_LIST_STRUCT_XrCameraExtrinsicsBD(_) \ + _(type) \ + _(next) \ + _(pose) \ + +/// Calls your macro with the name of each member of XrCameraCaptureBeginInfoBD, in order. +#define XR_LIST_STRUCT_XrCameraCaptureBeginInfoBD(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrCameraImageAcquireInfoBD, in order. +#define XR_LIST_STRUCT_XrCameraImageAcquireInfoBD(_) \ + _(type) \ + _(next) \ + _(lastCaptureTime) \ + +/// Calls your macro with the name of each member of XrCameraImageBD, in order. +#define XR_LIST_STRUCT_XrCameraImageBD(_) \ + _(type) \ + _(next) \ + _(available) \ + _(captureTime) \ + _(imageId) \ + +/// Calls your macro with the name of each member of XrCameraImageDataBaseHeaderBD, in order. +#define XR_LIST_STRUCT_XrCameraImageDataBaseHeaderBD(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrCameraImageDataRawBufferBD, in order. +#define XR_LIST_STRUCT_XrCameraImageDataRawBufferBD(_) \ + _(type) \ + _(next) \ + _(width) \ + _(height) \ + _(stride) \ + _(bytesPerPixel) \ + _(pixelStride) \ + _(bufferSize) \ + _(buffer) \ + +/// Calls your macro with the name of each member of XrSpatialBoundsSpherefANDROID, in order. +#define XR_LIST_STRUCT_XrSpatialBoundsSpherefANDROID(_) \ + _(type) \ + _(next) \ + _(space) \ + _(time) \ + _(sphere) \ + +/// Calls your macro with the name of each member of XrSpatialBoundsBoxfANDROID, in order. +#define XR_LIST_STRUCT_XrSpatialBoundsBoxfANDROID(_) \ + _(type) \ + _(next) \ + _(space) \ + _(time) \ + _(box) \ + +/// Calls your macro with the name of each member of XrSpatialBoundsFrustumfANDROID, in order. +#define XR_LIST_STRUCT_XrSpatialBoundsFrustumfANDROID(_) \ + _(type) \ + _(next) \ + _(space) \ + _(time) \ + _(frustum) \ + +/// Calls your macro with the name of each member of XrSpatialCapabilityConfigurationAnchorEXT, in order. +#define XR_LIST_STRUCT_XrSpatialCapabilityConfigurationAnchorEXT(_) \ + _(type) \ + _(next) \ + _(capability) \ + _(enabledComponentCount) \ + _(enabledComponents) \ + +/// Calls your macro with the name of each member of XrSpatialComponentAnchorListEXT, in order. +#define XR_LIST_STRUCT_XrSpatialComponentAnchorListEXT(_) \ + _(type) \ + _(next) \ + _(locationCount) \ + _(locations) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorCreateInfoEXT, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorCreateInfoEXT(_) \ + _(type) \ + _(next) \ + _(baseSpace) \ + _(time) \ + _(pose) \ + +/// Calls your macro with the name of each member of XrSpatialPersistenceContextCreateInfoEXT, in order. +#define XR_LIST_STRUCT_XrSpatialPersistenceContextCreateInfoEXT(_) \ + _(type) \ + _(next) \ + _(scope) \ + +/// Calls your macro with the name of each member of XrCreateSpatialPersistenceContextCompletionEXT, in order. +#define XR_LIST_STRUCT_XrCreateSpatialPersistenceContextCompletionEXT(_) \ + _(type) \ + _(next) \ + _(futureResult) \ + _(createResult) \ + _(persistenceContext) \ + +/// Calls your macro with the name of each member of XrSpatialContextPersistenceConfigEXT, in order. +#define XR_LIST_STRUCT_XrSpatialContextPersistenceConfigEXT(_) \ + _(type) \ + _(next) \ + _(persistenceContextCount) \ + _(persistenceContexts) \ + +/// Calls your macro with the name of each member of XrSpatialDiscoveryPersistenceUuidFilterEXT, in order. +#define XR_LIST_STRUCT_XrSpatialDiscoveryPersistenceUuidFilterEXT(_) \ + _(type) \ + _(next) \ + _(persistedUuidCount) \ + _(persistedUuids) \ + +/// Calls your macro with the name of each member of XrSpatialPersistenceDataEXT, in order. +#define XR_LIST_STRUCT_XrSpatialPersistenceDataEXT(_) \ + _(persistUuid) \ + _(persistState) \ + +/// Calls your macro with the name of each member of XrSpatialComponentPersistenceListEXT, in order. +#define XR_LIST_STRUCT_XrSpatialComponentPersistenceListEXT(_) \ + _(type) \ + _(next) \ + _(persistDataCount) \ + _(persistData) \ + +/// Calls your macro with the name of each member of XrHapticParametricPropertiesEXT, in order. +#define XR_LIST_STRUCT_XrHapticParametricPropertiesEXT(_) \ + _(type) \ + _(next) \ + _(idealFrameSubmissionRate) \ + _(minimumFirstFrameDuration) \ + _(minFrequencyHz) \ + _(maxFrequencyHz) \ + +/// Calls your macro with the name of each member of XrHapticParametricPointEXT, in order. +#define XR_LIST_STRUCT_XrHapticParametricPointEXT(_) \ + _(time) \ + _(value) \ + +/// Calls your macro with the name of each member of XrHapticParametricTransientEXT, in order. +#define XR_LIST_STRUCT_XrHapticParametricTransientEXT(_) \ + _(time) \ + _(amplitude) \ + _(frequency) \ + +/// Calls your macro with the name of each member of XrHapticParametricVibrationEXT, in order. +#define XR_LIST_STRUCT_XrHapticParametricVibrationEXT(_) \ + _(type) \ + _(next) \ + _(amplitudePointCount) \ + _(amplitudePoints) \ + _(frequencyPointCount) \ + _(frequencyPoints) \ + _(transientCount) \ + _(transients) \ + _(minFrequencyHz) \ + _(maxFrequencyHz) \ + _(streamFrameType) \ + +/// Calls your macro with the name of each member of XrSystemHapticParametricPropertiesEXT, in order. +#define XR_LIST_STRUCT_XrSystemHapticParametricPropertiesEXT(_) \ + _(type) \ + _(next) \ + _(supportsParametricHaptics) \ + +/// Calls your macro with the name of each member of XrColorSpacesEnumerateInfoSONY, in order. +#define XR_LIST_STRUCT_XrColorSpacesEnumerateInfoSONY(_) \ + _(type) \ + _(next) \ + _(format) \ + +/// Calls your macro with the name of each member of XrSwapchainCreateInfoColorSpaceSONY, in order. +#define XR_LIST_STRUCT_XrSwapchainCreateInfoColorSpaceSONY(_) \ + _(type) \ + _(next) \ + _(colorSpace) \ + +/// Calls your macro with the name of each member of XrXYColorSONY, in order. +#define XR_LIST_STRUCT_XrXYColorSONY(_) \ + _(x) \ + _(y) \ + +/// Calls your macro with the name of each member of XrHdrMetadataSONY, in order. +#define XR_LIST_STRUCT_XrHdrMetadataSONY(_) \ + _(type) \ + _(next) \ + _(displayPrimaryRed) \ + _(displayPrimaryGreen) \ + _(displayPrimaryBlue) \ + _(whitePoint) \ + _(maxLuminance) \ + _(minLuminance) \ + _(maxContentLightLevel) \ + _(maxFrameAverageLightLevel) \ + +/// Calls your macro with the name of each member of XrSpatialEntityPersistInfoEXT, in order. +#define XR_LIST_STRUCT_XrSpatialEntityPersistInfoEXT(_) \ + _(type) \ + _(next) \ + _(spatialContext) \ + _(spatialEntityId) \ + +/// Calls your macro with the name of each member of XrPersistSpatialEntityCompletionEXT, in order. +#define XR_LIST_STRUCT_XrPersistSpatialEntityCompletionEXT(_) \ + _(type) \ + _(next) \ + _(futureResult) \ + _(persistResult) \ + _(persistUuid) \ + +/// Calls your macro with the name of each member of XrSpatialEntityUnpersistInfoEXT, in order. +#define XR_LIST_STRUCT_XrSpatialEntityUnpersistInfoEXT(_) \ + _(type) \ + _(next) \ + _(persistUuid) \ + +/// Calls your macro with the name of each member of XrUnpersistSpatialEntityCompletionEXT, in order. +#define XR_LIST_STRUCT_XrUnpersistSpatialEntityCompletionEXT(_) \ + _(type) \ + _(next) \ + _(futureResult) \ + _(unpersistResult) \ + +/// Calls your macro with the name of each member of XrSpatialReferenceImagePlaneEXT, in order. +#define XR_LIST_STRUCT_XrSpatialReferenceImagePlaneEXT(_) \ + _(bufferSize) \ + _(buffer) \ + _(rowStride) \ + _(pixelStride) \ + +/// Calls your macro with the name of each member of XrSpatialReferenceImageEXT, in order. +#define XR_LIST_STRUCT_XrSpatialReferenceImageEXT(_) \ + _(type) \ + _(next) \ + _(width) \ + _(height) \ + _(format) \ + _(planeCount) \ + _(planes) \ + +/// Calls your macro with the name of each member of XrSpatialImageStaticOptimizationEXT, in order. +#define XR_LIST_STRUCT_XrSpatialImageStaticOptimizationEXT(_) \ + _(type) \ + _(next) \ + _(optimizeForStaticImage) \ + +/// Calls your macro with the name of each member of XrSpatialImageSizeEXT, in order. +#define XR_LIST_STRUCT_XrSpatialImageSizeEXT(_) \ + _(type) \ + _(next) \ + _(physicalWidth) \ + +/// Calls your macro with the name of each member of XrSpatialCapabilityConfigurationImageTrackingEXT, in order. +#define XR_LIST_STRUCT_XrSpatialCapabilityConfigurationImageTrackingEXT(_) \ + _(type) \ + _(next) \ + _(capability) \ + _(enabledComponentCount) \ + _(enabledComponents) \ + _(imageTrackingDatabaseCount) \ + _(imageTrackingDatabases) \ + +/// Calls your macro with the name of each member of XrSpatialImageTrackingDatabaseCreateInfoEXT, in order. +#define XR_LIST_STRUCT_XrSpatialImageTrackingDatabaseCreateInfoEXT(_) \ + _(type) \ + _(next) \ + _(spatialReferenceImageCount) \ + _(spatialReferenceImages) \ + +/// Calls your macro with the name of each member of XrSpatialImage2DDataEXT, in order. +#define XR_LIST_STRUCT_XrSpatialImage2DDataEXT(_) \ + _(imageTrackingDatabase) \ + _(referenceImageIndex) \ + +/// Calls your macro with the name of each member of XrSpatialComponentImage2DListEXT, in order. +#define XR_LIST_STRUCT_XrSpatialComponentImage2DListEXT(_) \ + _(type) \ + _(next) \ + _(imageCount) \ + _(images) \ + +/// Calls your macro with the name of each member of XrCreateSpatialImageTrackingDatabaseCompletionEXT, in order. +#define XR_LIST_STRUCT_XrCreateSpatialImageTrackingDatabaseCompletionEXT(_) \ + _(type) \ + _(next) \ + _(futureResult) \ + _(database) \ + +/// Calls your macro with the name of each member of XrSpatialCapabilityConfigurationObjectTrackingANDROID, in order. +#define XR_LIST_STRUCT_XrSpatialCapabilityConfigurationObjectTrackingANDROID(_) \ + _(type) \ + _(next) \ + _(capability) \ + _(enabledComponentCount) \ + _(enabledComponents) \ + _(activeSemanticLabelCount) \ + _(activeSemanticLabels) \ + +/// Calls your macro with the name of each member of XrSpatialComponentObjectSemanticLabelListANDROID, in order. +#define XR_LIST_STRUCT_XrSpatialComponentObjectSemanticLabelListANDROID(_) \ + _(type) \ + _(next) \ + _(semanticLabelCount) \ + _(semanticLabels) \ + +/// Calls your macro with the name of each member of XrSpatialRaycastResultDataANDROID, in order. +#define XR_LIST_STRUCT_XrSpatialRaycastResultDataANDROID(_) \ + _(hitPose) \ + _(distanceSquared) \ + +/// Calls your macro with the name of each member of XrSpatialCapabilityConfigurationDepthRaycastANDROID, in order. +#define XR_LIST_STRUCT_XrSpatialCapabilityConfigurationDepthRaycastANDROID(_) \ + _(type) \ + _(next) \ + _(capability) \ + _(enabledComponentCount) \ + _(enabledComponents) \ + +/// Calls your macro with the name of each member of XrSpatialRaycastInfoANDROID, in order. +#define XR_LIST_STRUCT_XrSpatialRaycastInfoANDROID(_) \ + _(type) \ + _(next) \ + _(space) \ + _(time) \ + _(origin) \ + _(direction) \ + _(maxDistance) \ + +/// Calls your macro with the name of each member of XrSpatialComponentRaycastResultListANDROID, in order. +#define XR_LIST_STRUCT_XrSpatialComponentRaycastResultListANDROID(_) \ + _(type) \ + _(next) \ + _(raycastResultCount) \ + _(raycastResults) \ + +/// Calls your macro with the name of each member of XrSpatialRaycastSnapshotCreateInfoANDROID, in order. +#define XR_LIST_STRUCT_XrSpatialRaycastSnapshotCreateInfoANDROID(_) \ + _(type) \ + _(next) \ + _(componentTypeCount) \ + _(componentTypes) \ + _(raycastInfo) \ + +/// Calls your macro with the name of each member of XrGoogleCloudAuthInfoBaseHeaderANDROID, in order. +#define XR_LIST_STRUCT_XrGoogleCloudAuthInfoBaseHeaderANDROID(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrGoogleCloudAuthInfoApiKeyANDROID, in order. +#define XR_LIST_STRUCT_XrGoogleCloudAuthInfoApiKeyANDROID(_) \ + _(type) \ + _(next) \ + _(apiKey) \ + +/// Calls your macro with the name of each member of XrGoogleCloudAuthInfoTokenANDROID, in order. +#define XR_LIST_STRUCT_XrGoogleCloudAuthInfoTokenANDROID(_) \ + _(type) \ + _(next) \ + _(authToken) \ + +/// Calls your macro with the name of each member of XrGoogleCloudAuthInfoKeylessANDROID, in order. +#define XR_LIST_STRUCT_XrGoogleCloudAuthInfoKeylessANDROID(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrGoogleCloudAuthErrorResultANDROID, in order. +#define XR_LIST_STRUCT_XrGoogleCloudAuthErrorResultANDROID(_) \ + _(type) \ + _(next) \ + _(error) \ + +/// Calls your macro with the name of each member of XrGeospatialPoseANDROID, in order. +#define XR_LIST_STRUCT_XrGeospatialPoseANDROID(_) \ + _(eastUpSouthOrientation) \ + _(latitude) \ + _(longitude) \ + _(altitude) \ + +/// Calls your macro with the name of each member of XrSystemGeospatialPropertiesANDROID, in order. +#define XR_LIST_STRUCT_XrSystemGeospatialPropertiesANDROID(_) \ + _(type) \ + _(next) \ + _(supportsGeospatial) \ + +/// Calls your macro with the name of each member of XrGeospatialTrackerCreateInfoANDROID, in order. +#define XR_LIST_STRUCT_XrGeospatialTrackerCreateInfoANDROID(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrEventDataGeospatialTrackerStateChangedANDROID, in order. +#define XR_LIST_STRUCT_XrEventDataGeospatialTrackerStateChangedANDROID(_) \ + _(type) \ + _(next) \ + _(geospatialTracker) \ + _(state) \ + _(initializationResult) \ + _(time) \ + +/// Calls your macro with the name of each member of XrGeospatialPoseFromPoseLocateInfoANDROID, in order. +#define XR_LIST_STRUCT_XrGeospatialPoseFromPoseLocateInfoANDROID(_) \ + _(type) \ + _(next) \ + _(space) \ + _(time) \ + _(pose) \ + +/// Calls your macro with the name of each member of XrGeospatialPoseResultANDROID, in order. +#define XR_LIST_STRUCT_XrGeospatialPoseResultANDROID(_) \ + _(type) \ + _(next) \ + _(poseFlags) \ + _(geospatialPose) \ + _(horizontalAccuracy) \ + _(verticalAccuracy) \ + _(orientationYawAccuracy) \ + +/// Calls your macro with the name of each member of XrGeospatialPoseLocateInfoANDROID, in order. +#define XR_LIST_STRUCT_XrGeospatialPoseLocateInfoANDROID(_) \ + _(type) \ + _(next) \ + _(space) \ + _(time) \ + _(geospatialPose) \ + +/// Calls your macro with the name of each member of XrVPSAvailabilityCheckCompletionANDROID, in order. +#define XR_LIST_STRUCT_XrVPSAvailabilityCheckCompletionANDROID(_) \ + _(type) \ + _(next) \ + _(futureResult) \ + _(availability) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorParentANDROID, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorParentANDROID(_) \ + _(type) \ + _(next) \ + _(parentId) \ + +/// Calls your macro with the name of each member of XrSpatialDiscoveryUniqueEntitiesFilterANDROID, in order. +#define XR_LIST_STRUCT_XrSpatialDiscoveryUniqueEntitiesFilterANDROID(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSpatialComponentSubsumedByListANDROID, in order. +#define XR_LIST_STRUCT_XrSpatialComponentSubsumedByListANDROID(_) \ + _(type) \ + _(next) \ + _(subsumedUniqueIdCount) \ + _(subsumedUniqueIds) \ + +/// Calls your macro with the name of each member of XrSpatialAnchorSpaceFromIdCreateInfoANDROID, in order. +#define XR_LIST_STRUCT_XrSpatialAnchorSpaceFromIdCreateInfoANDROID(_) \ + _(type) \ + _(next) \ + _(anchorEntityId) \ + +/// Calls your macro with the name of each member of XrSystemGeospatialAnchorPropertiesANDROID, in order. +#define XR_LIST_STRUCT_XrSystemGeospatialAnchorPropertiesANDROID(_) \ + _(type) \ + _(next) \ + _(maxSurfaceAnchorCount) \ + +/// Calls your macro with the name of each member of XrGeospatialTrackerAnchorTrackingInfoANDROID, in order. +#define XR_LIST_STRUCT_XrGeospatialTrackerAnchorTrackingInfoANDROID(_) \ + _(type) \ + _(next) \ + _(shouldTrackPlanes) \ + +/// Calls your macro with the name of each member of XrGeospatialAnchorCreateInfoANDROID, in order. +#define XR_LIST_STRUCT_XrGeospatialAnchorCreateInfoANDROID(_) \ + _(type) \ + _(next) \ + _(geospatialTracker) \ + _(geospatialPose) \ + +/// Calls your macro with the name of each member of XrSurfaceAnchorCreateInfoANDROID, in order. +#define XR_LIST_STRUCT_XrSurfaceAnchorCreateInfoANDROID(_) \ + _(type) \ + _(next) \ + _(geospatialTracker) \ + _(surfaceAnchorType) \ + _(eastUpSouthOrientation) \ + _(latitude) \ + _(longitude) \ + _(altitudeRelativeToSurface) \ + +/// Calls your macro with the name of each member of XrSurfaceAnchorCreateCompletionANDROID, in order. +#define XR_LIST_STRUCT_XrSurfaceAnchorCreateCompletionANDROID(_) \ + _(type) \ + _(next) \ + _(futureResult) \ + _(anchorEntityId) \ + +/// Calls your macro with the name of each member of XrSessionCreateInfoSpatialContainersEXT, in order. +#define XR_LIST_STRUCT_XrSessionCreateInfoSpatialContainersEXT(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSpatialContainerCreateInfoEXT, in order. +#define XR_LIST_STRUCT_XrSpatialContainerCreateInfoEXT(_) \ + _(type) \ + _(next) \ + _(graphicsPresentation) \ + _(suggestedBounds) \ + +/// Calls your macro with the name of each member of XrSpatialContainerSpaceCreateInfoEXT, in order. +#define XR_LIST_STRUCT_XrSpatialContainerSpaceCreateInfoEXT(_) \ + _(type) \ + _(next) \ + _(spatialContainer) \ + +/// Calls your macro with the name of each member of XrEventDataSpatialContainerClosedEXT, in order. +#define XR_LIST_STRUCT_XrEventDataSpatialContainerClosedEXT(_) \ + _(type) \ + _(next) \ + _(spatialContainer) \ + +/// Calls your macro with the name of each member of XrSystemSpatialContainerPropertiesEXT, in order. +#define XR_LIST_STRUCT_XrSystemSpatialContainerPropertiesEXT(_) \ + _(type) \ + _(next) \ + _(maxSpatialContainerCount) \ + _(supportsBounded) \ + _(supportsImmersive) \ + +/// Calls your macro with the name of each member of XrSpatialContainerBoundsEXT, in order. +#define XR_LIST_STRUCT_XrSpatialContainerBoundsEXT(_) \ + _(type) \ + _(next) \ + _(bounds) \ + _(infiniteBounds) \ + +/// Calls your macro with the name of each member of XrEventDataSpatialContainerBoundsChangedEXT, in order. +#define XR_LIST_STRUCT_XrEventDataSpatialContainerBoundsChangedEXT(_) \ + _(type) \ + _(next) \ + _(spatialContainer) \ + _(bounds) \ + _(infiniteBounds) \ + _(boundsMode) \ + +/// Calls your macro with the name of each member of XrSpatialContainerBoundsGetInfoEXT, in order. +#define XR_LIST_STRUCT_XrSpatialContainerBoundsGetInfoEXT(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSpatialContainerStateGetInfoEXT, in order. +#define XR_LIST_STRUCT_XrSpatialContainerStateGetInfoEXT(_) \ + _(type) \ + _(next) \ + +/// Calls your macro with the name of each member of XrSpatialContainerVisibleRequestInfoEXT, in order. +#define XR_LIST_STRUCT_XrSpatialContainerVisibleRequestInfoEXT(_) \ + _(type) \ + _(next) \ + _(visible) \ + +/// Calls your macro with the name of each member of XrEventDataSpatialContainerVisibleChangedEXT, in order. +#define XR_LIST_STRUCT_XrEventDataSpatialContainerVisibleChangedEXT(_) \ + _(type) \ + _(next) \ + _(spatialContainer) \ + _(visible) \ + +/// Calls your macro with the name of each member of XrEventDataSpatialContainerVisibleRequestDeniedEXT, in order. +#define XR_LIST_STRUCT_XrEventDataSpatialContainerVisibleRequestDeniedEXT(_) \ + _(type) \ + _(next) \ + _(spatialContainer) \ + +/// Calls your macro with the name of each member of XrEventDataSpatialContainerInteractableChangedEXT, in order. +#define XR_LIST_STRUCT_XrEventDataSpatialContainerInteractableChangedEXT(_) \ + _(type) \ + _(next) \ + _(spatialContainer) \ + _(interactable) \ + +/// Calls your macro with the name of each member of XrSpatialContainerBoundsModeRequestInfoEXT, in order. +#define XR_LIST_STRUCT_XrSpatialContainerBoundsModeRequestInfoEXT(_) \ + _(type) \ + _(next) \ + _(boundsMode) \ + +/// Calls your macro with the name of each member of XrEventDataSpatialContainerBoundsModeRequestDeniedEXT, in order. +#define XR_LIST_STRUCT_XrEventDataSpatialContainerBoundsModeRequestDeniedEXT(_) \ + _(type) \ + _(next) \ + _(spatialContainer) \ + +/// Calls your macro with the name of each member of XrSpatialContainerStateEXT, in order. +#define XR_LIST_STRUCT_XrSpatialContainerStateEXT(_) \ + _(type) \ + _(next) \ + _(visible) \ + _(interactable) \ + _(boundsMode) \ + +/// Calls your macro with the name of each member of XrSpatialContainerViewLocateInfoEXT, in order. +#define XR_LIST_STRUCT_XrSpatialContainerViewLocateInfoEXT(_) \ + _(type) \ + _(next) \ + _(viewConfigurationType) \ + _(space) \ + _(spatialContainer) \ + +/// Calls your macro with the name of each member of XrSpatialContainerViewsLocateInfoEXT, in order. +#define XR_LIST_STRUCT_XrSpatialContainerViewsLocateInfoEXT(_) \ + _(type) \ + _(next) \ + _(displayTime) \ + _(viewLocateInfoCount) \ + _(viewLocateInfos) \ + +/// Calls your macro with the name of each member of XrSpatialContainerViewStateEXT, in order. +#define XR_LIST_STRUCT_XrSpatialContainerViewStateEXT(_) \ + _(type) \ + _(next) \ + _(viewStateFlags) \ + _(viewConfigurationType) \ + _(shouldSubmitLayers) \ + _(recommendedImageExtent) \ + +/// Calls your macro with the name of each member of XrSpatialContainerLayerEXT, in order. +#define XR_LIST_STRUCT_XrSpatialContainerLayerEXT(_) \ + _(type) \ + _(next) \ + _(spatialContainer) \ + _(retainPreviousSubmission) \ + _(layerCount) \ + _(layers) \ + +/// Calls your macro with the name of each member of XrSpatialContainerLayerFrameEndInfoEXT, in order. +#define XR_LIST_STRUCT_XrSpatialContainerLayerFrameEndInfoEXT(_) \ + _(type) \ + _(next) \ + _(containerLayerCount) \ + _(containerLayers) \ + +/// Calls your macro with the name of each member of XrSpatialContainerBeginInfoEXT, in order. +#define XR_LIST_STRUCT_XrSpatialContainerBeginInfoEXT(_) \ + _(type) \ + _(next) \ + _(spatialContainer) \ + _(primaryViewConfigurationType) \ + +/// Calls your macro with the name of each member of XrSpatialContainerEndInfoEXT, in order. +#define XR_LIST_STRUCT_XrSpatialContainerEndInfoEXT(_) \ + _(type) \ + _(next) \ + _(spatialContainer) \ + +/// Calls your macro with the name of each member of XrSpatialContainerCompositionLayerViewConfigurationEXT, in order. +#define XR_LIST_STRUCT_XrSpatialContainerCompositionLayerViewConfigurationEXT(_) \ + _(type) \ + _(next) \ + _(viewConfigurationType) \ + +/// Calls your macro with the name of each member of XrSpatialContainerLayerVolumeClippingEXT, in order. +#define XR_LIST_STRUCT_XrSpatialContainerLayerVolumeClippingEXT(_) \ + _(type) \ + _(next) \ + _(volumeClipping) \ + +/// Calls your macro with the name of each member of XrBatteryStateDisplayEXT, in order. +#define XR_LIST_STRUCT_XrBatteryStateDisplayEXT(_) \ + _(type) \ + _(next) \ + _(stateFlags) \ + _(batteryLevel) \ + +/// Calls your macro with the name of each member of XrLoaderInitPropertyValueEXT, in order. +#define XR_LIST_STRUCT_XrLoaderInitPropertyValueEXT(_) \ + _(name) \ + _(value) \ + +/// Calls your macro with the name of each member of XrLoaderInitInfoPropertiesEXT, in order. +#define XR_LIST_STRUCT_XrLoaderInitInfoPropertiesEXT(_) \ + _(type) \ + _(next) \ + _(propertyValueCount) \ + _(propertyValues) \ + +/// Calls your macro with the name of each member of XrEventDataViewConfigurationViewsChangedEXT, in order. +#define XR_LIST_STRUCT_XrEventDataViewConfigurationViewsChangedEXT(_) \ + _(type) \ + _(next) \ + _(systemId) \ + _(viewConfigurationType) \ + + + +/// Calls your macro with the structure type name and the XrStructureType constant for +/// each known/available structure type, excluding those unavailable due to preprocessor definitions. +#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_METAL(_) \ + 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_ML(_) \ + XR_LIST_STRUCTURE_TYPES_XR_USE_PLATFORM_WIN32(_) \ + + +/// Implementation detail of XR_LIST_STRUCTURE_TYPES() - structure types available without any preprocessor definitions +#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) \ + _(XrReferenceSpaceCreateInfo, XR_TYPE_REFERENCE_SPACE_CREATE_INFO) \ + _(XrActionSpaceCreateInfo, XR_TYPE_ACTION_SPACE_CREATE_INFO) \ + _(XrSpaceLocation, XR_TYPE_SPACE_LOCATION) \ + _(XrSpaceVelocity, XR_TYPE_SPACE_VELOCITY) \ + _(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) \ + _(XrFrameState, XR_TYPE_FRAME_STATE) \ + _(XrFrameWaitInfo, XR_TYPE_FRAME_WAIT_INFO) \ + _(XrFrameBeginInfo, XR_TYPE_FRAME_BEGIN_INFO) \ + _(XrFrameEndInfo, XR_TYPE_FRAME_END_INFO) \ + _(XrViewState, XR_TYPE_VIEW_STATE) \ + _(XrViewLocateInfo, XR_TYPE_VIEW_LOCATE_INFO) \ + _(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) \ + _(XrSpacesLocateInfo, XR_TYPE_SPACES_LOCATE_INFO) \ + _(XrSpaceLocations, XR_TYPE_SPACE_LOCATIONS) \ + _(XrSpaceVelocities, XR_TYPE_SPACE_VELOCITIES) \ + _(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) \ + _(XrSpatialGraphStaticNodeBindingCreateInfoMSFT, XR_TYPE_SPATIAL_GRAPH_STATIC_NODE_BINDING_CREATE_INFO_MSFT) \ + _(XrSpatialGraphNodeBindingPropertiesGetInfoMSFT, XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_GET_INFO_MSFT) \ + _(XrSpatialGraphNodeBindingPropertiesMSFT, XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_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) \ + _(XrSystemBodyTrackingPropertiesFB, XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_FB) \ + _(XrBodyTrackerCreateInfoFB, XR_TYPE_BODY_TRACKER_CREATE_INFO_FB) \ + _(XrBodySkeletonFB, XR_TYPE_BODY_SKELETON_FB) \ + _(XrBodyJointsLocateInfoFB, XR_TYPE_BODY_JOINTS_LOCATE_INFO_FB) \ + _(XrBodyJointLocationsFB, XR_TYPE_BODY_JOINT_LOCATIONS_FB) \ + _(XrInteractionProfileDpadBindingEXT, XR_TYPE_INTERACTION_PROFILE_DPAD_BINDING_EXT) \ + _(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) \ + _(XrSystemSpatialEntityPropertiesFB, XR_TYPE_SYSTEM_SPATIAL_ENTITY_PROPERTIES_FB) \ + _(XrSpatialAnchorCreateInfoFB, XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_FB) \ + _(XrSpaceComponentStatusSetInfoFB, XR_TYPE_SPACE_COMPONENT_STATUS_SET_INFO_FB) \ + _(XrSpaceComponentStatusFB, XR_TYPE_SPACE_COMPONENT_STATUS_FB) \ + _(XrEventDataSpatialAnchorCreateCompleteFB, XR_TYPE_EVENT_DATA_SPATIAL_ANCHOR_CREATE_COMPLETE_FB) \ + _(XrEventDataSpaceSetStatusCompleteFB, XR_TYPE_EVENT_DATA_SPACE_SET_STATUS_COMPLETE_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) \ + _(XrSystemPassthroughProperties2FB, XR_TYPE_SYSTEM_PASSTHROUGH_PROPERTIES2_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) \ + _(XrPassthroughBrightnessContrastSaturationFB, XR_TYPE_PASSTHROUGH_BRIGHTNESS_CONTRAST_SATURATION_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) \ + _(XrRenderModelCapabilitiesRequestFB, XR_TYPE_RENDER_MODEL_CAPABILITIES_REQUEST_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) \ + _(XrFrameEndInfoML, XR_TYPE_FRAME_END_INFO_ML) \ + _(XrGlobalDimmerFrameEndInfoML, XR_TYPE_GLOBAL_DIMMER_FRAME_END_INFO_ML) \ + _(XrSystemMarkerUnderstandingPropertiesML, XR_TYPE_SYSTEM_MARKER_UNDERSTANDING_PROPERTIES_ML) \ + _(XrMarkerDetectorCreateInfoML, XR_TYPE_MARKER_DETECTOR_CREATE_INFO_ML) \ + _(XrMarkerDetectorArucoInfoML, XR_TYPE_MARKER_DETECTOR_ARUCO_INFO_ML) \ + _(XrMarkerDetectorSizeInfoML, XR_TYPE_MARKER_DETECTOR_SIZE_INFO_ML) \ + _(XrMarkerDetectorAprilTagInfoML, XR_TYPE_MARKER_DETECTOR_APRIL_TAG_INFO_ML) \ + _(XrMarkerDetectorCustomProfileInfoML, XR_TYPE_MARKER_DETECTOR_CUSTOM_PROFILE_INFO_ML) \ + _(XrMarkerDetectorSnapshotInfoML, XR_TYPE_MARKER_DETECTOR_SNAPSHOT_INFO_ML) \ + _(XrMarkerDetectorStateML, XR_TYPE_MARKER_DETECTOR_STATE_ML) \ + _(XrMarkerSpaceCreateInfoML, XR_TYPE_MARKER_SPACE_CREATE_INFO_ML) \ + _(XrLocalizationMapML, XR_TYPE_LOCALIZATION_MAP_ML) \ + _(XrEventDataLocalizationChangedML, XR_TYPE_EVENT_DATA_LOCALIZATION_CHANGED_ML) \ + _(XrMapLocalizationRequestInfoML, XR_TYPE_MAP_LOCALIZATION_REQUEST_INFO_ML) \ + _(XrLocalizationMapImportInfoML, XR_TYPE_LOCALIZATION_MAP_IMPORT_INFO_ML) \ + _(XrLocalizationEnableEventsInfoML, XR_TYPE_LOCALIZATION_ENABLE_EVENTS_INFO_ML) \ + _(XrSpatialAnchorsCreateInfoFromPoseML, XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_POSE_ML) \ + _(XrCreateSpatialAnchorsCompletionML, XR_TYPE_CREATE_SPATIAL_ANCHORS_COMPLETION_ML) \ + _(XrSpatialAnchorStateML, XR_TYPE_SPATIAL_ANCHOR_STATE_ML) \ + _(XrSpatialAnchorsCreateStorageInfoML, XR_TYPE_SPATIAL_ANCHORS_CREATE_STORAGE_INFO_ML) \ + _(XrSpatialAnchorsQueryInfoRadiusML, XR_TYPE_SPATIAL_ANCHORS_QUERY_INFO_RADIUS_ML) \ + _(XrSpatialAnchorsQueryCompletionML, XR_TYPE_SPATIAL_ANCHORS_QUERY_COMPLETION_ML) \ + _(XrSpatialAnchorsCreateInfoFromUuidsML, XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_UUIDS_ML) \ + _(XrSpatialAnchorsPublishInfoML, XR_TYPE_SPATIAL_ANCHORS_PUBLISH_INFO_ML) \ + _(XrSpatialAnchorsPublishCompletionML, XR_TYPE_SPATIAL_ANCHORS_PUBLISH_COMPLETION_ML) \ + _(XrSpatialAnchorsDeleteInfoML, XR_TYPE_SPATIAL_ANCHORS_DELETE_INFO_ML) \ + _(XrSpatialAnchorsDeleteCompletionML, XR_TYPE_SPATIAL_ANCHORS_DELETE_COMPLETION_ML) \ + _(XrSpatialAnchorsUpdateExpirationInfoML, XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_INFO_ML) \ + _(XrSpatialAnchorsUpdateExpirationCompletionML, XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_COMPLETION_ML) \ + _(XrSpatialAnchorsPublishCompletionDetailsML, XR_TYPE_SPATIAL_ANCHORS_PUBLISH_COMPLETION_DETAILS_ML) \ + _(XrSpatialAnchorsDeleteCompletionDetailsML, XR_TYPE_SPATIAL_ANCHORS_DELETE_COMPLETION_DETAILS_ML) \ + _(XrSpatialAnchorsUpdateExpirationCompletionDetailsML, XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_COMPLETION_DETAILS_ML) \ + _(XrSpatialAnchorPersistenceInfoMSFT, XR_TYPE_SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT) \ + _(XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT, XR_TYPE_SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_INFO_MSFT) \ + _(XrSceneMarkersMSFT, XR_TYPE_SCENE_MARKERS_MSFT) \ + _(XrSceneMarkerTypeFilterMSFT, XR_TYPE_SCENE_MARKER_TYPE_FILTER_MSFT) \ + _(XrSceneMarkerQRCodesMSFT, XR_TYPE_SCENE_MARKER_QR_CODES_MSFT) \ + _(XrSpaceQueryInfoFB, XR_TYPE_SPACE_QUERY_INFO_FB) \ + _(XrSpaceStorageLocationFilterInfoFB, XR_TYPE_SPACE_STORAGE_LOCATION_FILTER_INFO_FB) \ + _(XrSpaceUuidFilterInfoFB, XR_TYPE_SPACE_UUID_FILTER_INFO_FB) \ + _(XrSpaceComponentFilterInfoFB, XR_TYPE_SPACE_COMPONENT_FILTER_INFO_FB) \ + _(XrSpaceQueryResultsFB, XR_TYPE_SPACE_QUERY_RESULTS_FB) \ + _(XrEventDataSpaceQueryResultsAvailableFB, XR_TYPE_EVENT_DATA_SPACE_QUERY_RESULTS_AVAILABLE_FB) \ + _(XrEventDataSpaceQueryCompleteFB, XR_TYPE_EVENT_DATA_SPACE_QUERY_COMPLETE_FB) \ + _(XrSpaceSaveInfoFB, XR_TYPE_SPACE_SAVE_INFO_FB) \ + _(XrSpaceEraseInfoFB, XR_TYPE_SPACE_ERASE_INFO_FB) \ + _(XrEventDataSpaceSaveCompleteFB, XR_TYPE_EVENT_DATA_SPACE_SAVE_COMPLETE_FB) \ + _(XrEventDataSpaceEraseCompleteFB, XR_TYPE_EVENT_DATA_SPACE_ERASE_COMPLETE_FB) \ + _(XrSpaceShareInfoFB, XR_TYPE_SPACE_SHARE_INFO_FB) \ + _(XrEventDataSpaceShareCompleteFB, XR_TYPE_EVENT_DATA_SPACE_SHARE_COMPLETE_FB) \ + _(XrCompositionLayerSpaceWarpInfoFB, XR_TYPE_COMPOSITION_LAYER_SPACE_WARP_INFO_FB) \ + _(XrSystemSpaceWarpPropertiesFB, XR_TYPE_SYSTEM_SPACE_WARP_PROPERTIES_FB) \ + _(XrHapticAmplitudeEnvelopeVibrationFB, XR_TYPE_HAPTIC_AMPLITUDE_ENVELOPE_VIBRATION_FB) \ + _(XrSemanticLabelsFB, XR_TYPE_SEMANTIC_LABELS_FB) \ + _(XrRoomLayoutFB, XR_TYPE_ROOM_LAYOUT_FB) \ + _(XrBoundary2DFB, XR_TYPE_BOUNDARY_2D_FB) \ + _(XrSemanticLabelsSupportInfoFB, XR_TYPE_SEMANTIC_LABELS_SUPPORT_INFO_FB) \ + _(XrDigitalLensControlALMALENCE, XR_TYPE_DIGITAL_LENS_CONTROL_ALMALENCE) \ + _(XrEventDataSceneCaptureCompleteFB, XR_TYPE_EVENT_DATA_SCENE_CAPTURE_COMPLETE_FB) \ + _(XrSceneCaptureRequestInfoFB, XR_TYPE_SCENE_CAPTURE_REQUEST_INFO_FB) \ + _(XrSpaceContainerFB, XR_TYPE_SPACE_CONTAINER_FB) \ + _(XrFoveationEyeTrackedProfileCreateInfoMETA, XR_TYPE_FOVEATION_EYE_TRACKED_PROFILE_CREATE_INFO_META) \ + _(XrFoveationEyeTrackedStateMETA, XR_TYPE_FOVEATION_EYE_TRACKED_STATE_META) \ + _(XrSystemFoveationEyeTrackedPropertiesMETA, XR_TYPE_SYSTEM_FOVEATION_EYE_TRACKED_PROPERTIES_META) \ + _(XrSystemFaceTrackingPropertiesFB, XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES_FB) \ + _(XrFaceTrackerCreateInfoFB, XR_TYPE_FACE_TRACKER_CREATE_INFO_FB) \ + _(XrFaceExpressionInfoFB, XR_TYPE_FACE_EXPRESSION_INFO_FB) \ + _(XrFaceExpressionWeightsFB, XR_TYPE_FACE_EXPRESSION_WEIGHTS_FB) \ + _(XrEyeTrackerCreateInfoFB, XR_TYPE_EYE_TRACKER_CREATE_INFO_FB) \ + _(XrEyeGazesInfoFB, XR_TYPE_EYE_GAZES_INFO_FB) \ + _(XrSystemEyeTrackingPropertiesFB, XR_TYPE_SYSTEM_EYE_TRACKING_PROPERTIES_FB) \ + _(XrEyeGazesFB, XR_TYPE_EYE_GAZES_FB) \ + _(XrPassthroughKeyboardHandsIntensityFB, XR_TYPE_PASSTHROUGH_KEYBOARD_HANDS_INTENSITY_FB) \ + _(XrCompositionLayerSettingsFB, XR_TYPE_COMPOSITION_LAYER_SETTINGS_FB) \ + _(XrHapticPcmVibrationFB, XR_TYPE_HAPTIC_PCM_VIBRATION_FB) \ + _(XrDevicePcmSampleRateStateFB, XR_TYPE_DEVICE_PCM_SAMPLE_RATE_STATE_FB) \ + _(XrFrameSynthesisInfoEXT, XR_TYPE_FRAME_SYNTHESIS_INFO_EXT) \ + _(XrFrameSynthesisConfigViewEXT, XR_TYPE_FRAME_SYNTHESIS_CONFIG_VIEW_EXT) \ + _(XrCompositionLayerDepthTestFB, XR_TYPE_COMPOSITION_LAYER_DEPTH_TEST_FB) \ + _(XrLocalDimmingFrameEndInfoMETA, XR_TYPE_LOCAL_DIMMING_FRAME_END_INFO_META) \ + _(XrPassthroughPreferencesMETA, XR_TYPE_PASSTHROUGH_PREFERENCES_META) \ + _(XrSystemVirtualKeyboardPropertiesMETA, XR_TYPE_SYSTEM_VIRTUAL_KEYBOARD_PROPERTIES_META) \ + _(XrVirtualKeyboardCreateInfoMETA, XR_TYPE_VIRTUAL_KEYBOARD_CREATE_INFO_META) \ + _(XrVirtualKeyboardSpaceCreateInfoMETA, XR_TYPE_VIRTUAL_KEYBOARD_SPACE_CREATE_INFO_META) \ + _(XrVirtualKeyboardLocationInfoMETA, XR_TYPE_VIRTUAL_KEYBOARD_LOCATION_INFO_META) \ + _(XrVirtualKeyboardModelVisibilitySetInfoMETA, XR_TYPE_VIRTUAL_KEYBOARD_MODEL_VISIBILITY_SET_INFO_META) \ + _(XrVirtualKeyboardAnimationStateMETA, XR_TYPE_VIRTUAL_KEYBOARD_ANIMATION_STATE_META) \ + _(XrVirtualKeyboardModelAnimationStatesMETA, XR_TYPE_VIRTUAL_KEYBOARD_MODEL_ANIMATION_STATES_META) \ + _(XrVirtualKeyboardTextureDataMETA, XR_TYPE_VIRTUAL_KEYBOARD_TEXTURE_DATA_META) \ + _(XrVirtualKeyboardInputInfoMETA, XR_TYPE_VIRTUAL_KEYBOARD_INPUT_INFO_META) \ + _(XrVirtualKeyboardTextContextChangeInfoMETA, XR_TYPE_VIRTUAL_KEYBOARD_TEXT_CONTEXT_CHANGE_INFO_META) \ + _(XrEventDataVirtualKeyboardCommitTextMETA, XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_COMMIT_TEXT_META) \ + _(XrEventDataVirtualKeyboardBackspaceMETA, XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_BACKSPACE_META) \ + _(XrEventDataVirtualKeyboardEnterMETA, XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_ENTER_META) \ + _(XrEventDataVirtualKeyboardShownMETA, XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_SHOWN_META) \ + _(XrEventDataVirtualKeyboardHiddenMETA, XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_HIDDEN_META) \ + _(XrExternalCameraOCULUS, XR_TYPE_EXTERNAL_CAMERA_OCULUS) \ + _(XrPerformanceMetricsStateMETA, XR_TYPE_PERFORMANCE_METRICS_STATE_META) \ + _(XrPerformanceMetricsCounterMETA, XR_TYPE_PERFORMANCE_METRICS_COUNTER_META) \ + _(XrSpaceListSaveInfoFB, XR_TYPE_SPACE_LIST_SAVE_INFO_FB) \ + _(XrEventDataSpaceListSaveCompleteFB, XR_TYPE_EVENT_DATA_SPACE_LIST_SAVE_COMPLETE_FB) \ + _(XrSpaceUserCreateInfoFB, XR_TYPE_SPACE_USER_CREATE_INFO_FB) \ + _(XrSystemHeadsetIdPropertiesMETA, XR_TYPE_SYSTEM_HEADSET_ID_PROPERTIES_META) \ + _(XrSystemSpaceDiscoveryPropertiesMETA, XR_TYPE_SYSTEM_SPACE_DISCOVERY_PROPERTIES_META) \ + _(XrSpaceDiscoveryInfoMETA, XR_TYPE_SPACE_DISCOVERY_INFO_META) \ + _(XrSpaceFilterUuidMETA, XR_TYPE_SPACE_FILTER_UUID_META) \ + _(XrSpaceFilterComponentMETA, XR_TYPE_SPACE_FILTER_COMPONENT_META) \ + _(XrSpaceDiscoveryResultsMETA, XR_TYPE_SPACE_DISCOVERY_RESULTS_META) \ + _(XrEventDataSpaceDiscoveryResultsAvailableMETA, XR_TYPE_EVENT_DATA_SPACE_DISCOVERY_RESULTS_AVAILABLE_META) \ + _(XrEventDataSpaceDiscoveryCompleteMETA, XR_TYPE_EVENT_DATA_SPACE_DISCOVERY_COMPLETE_META) \ + _(XrRecommendedLayerResolutionMETA, XR_TYPE_RECOMMENDED_LAYER_RESOLUTION_META) \ + _(XrRecommendedLayerResolutionGetInfoMETA, XR_TYPE_RECOMMENDED_LAYER_RESOLUTION_GET_INFO_META) \ + _(XrSystemSpacePersistencePropertiesMETA, XR_TYPE_SYSTEM_SPACE_PERSISTENCE_PROPERTIES_META) \ + _(XrSpacesSaveInfoMETA, XR_TYPE_SPACES_SAVE_INFO_META) \ + _(XrEventDataSpacesSaveResultMETA, XR_TYPE_EVENT_DATA_SPACES_SAVE_RESULT_META) \ + _(XrSpacesEraseInfoMETA, XR_TYPE_SPACES_ERASE_INFO_META) \ + _(XrEventDataSpacesEraseResultMETA, XR_TYPE_EVENT_DATA_SPACES_ERASE_RESULT_META) \ + _(XrPassthroughColorLutCreateInfoMETA, XR_TYPE_PASSTHROUGH_COLOR_LUT_CREATE_INFO_META) \ + _(XrPassthroughColorLutUpdateInfoMETA, XR_TYPE_PASSTHROUGH_COLOR_LUT_UPDATE_INFO_META) \ + _(XrPassthroughColorMapLutMETA, XR_TYPE_PASSTHROUGH_COLOR_MAP_LUT_META) \ + _(XrPassthroughColorMapInterpolatedLutMETA, XR_TYPE_PASSTHROUGH_COLOR_MAP_INTERPOLATED_LUT_META) \ + _(XrSystemPassthroughColorLutPropertiesMETA, XR_TYPE_SYSTEM_PASSTHROUGH_COLOR_LUT_PROPERTIES_META) \ + _(XrSpaceTriangleMeshGetInfoMETA, XR_TYPE_SPACE_TRIANGLE_MESH_GET_INFO_META) \ + _(XrSpaceTriangleMeshMETA, XR_TYPE_SPACE_TRIANGLE_MESH_META) \ + _(XrSystemPropertiesBodyTrackingFullBodyMETA, XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_FULL_BODY_META) \ + _(XrEventDataPassthroughLayerResumedMETA, XR_TYPE_EVENT_DATA_PASSTHROUGH_LAYER_RESUMED_META) \ + _(XrBodyTrackingCalibrationStatusMETA, XR_TYPE_BODY_TRACKING_CALIBRATION_STATUS_META) \ + _(XrBodyTrackingCalibrationInfoMETA, XR_TYPE_BODY_TRACKING_CALIBRATION_INFO_META) \ + _(XrSystemPropertiesBodyTrackingCalibrationMETA, XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_CALIBRATION_META) \ + _(XrSystemPropertiesBodyTrackingFidelityMETA, XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_FIDELITY_META) \ + _(XrBodyTrackingFidelityStatusMETA, XR_TYPE_BODY_TRACKING_FIDELITY_STATUS_META) \ + _(XrSystemFaceTrackingProperties2FB, XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES2_FB) \ + _(XrFaceTrackerCreateInfo2FB, XR_TYPE_FACE_TRACKER_CREATE_INFO2_FB) \ + _(XrFaceExpressionInfo2FB, XR_TYPE_FACE_EXPRESSION_INFO2_FB) \ + _(XrFaceExpressionWeights2FB, XR_TYPE_FACE_EXPRESSION_WEIGHTS2_FB) \ + _(XrSystemSpatialEntitySharingPropertiesMETA, XR_TYPE_SYSTEM_SPATIAL_ENTITY_SHARING_PROPERTIES_META) \ + _(XrShareSpacesInfoMETA, XR_TYPE_SHARE_SPACES_INFO_META) \ + _(XrEventDataShareSpacesCompleteMETA, XR_TYPE_EVENT_DATA_SHARE_SPACES_COMPLETE_META) \ + _(XrEnvironmentDepthProviderCreateInfoMETA, XR_TYPE_ENVIRONMENT_DEPTH_PROVIDER_CREATE_INFO_META) \ + _(XrEnvironmentDepthSwapchainCreateInfoMETA, XR_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_CREATE_INFO_META) \ + _(XrEnvironmentDepthSwapchainStateMETA, XR_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_STATE_META) \ + _(XrEnvironmentDepthImageAcquireInfoMETA, XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_ACQUIRE_INFO_META) \ + _(XrEnvironmentDepthImageViewMETA, XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_VIEW_META) \ + _(XrEnvironmentDepthImageMETA, XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_META) \ + _(XrEnvironmentDepthImageTimestampMETA, XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_TIMESTAMP_META) \ + _(XrEnvironmentDepthHandRemovalSetInfoMETA, XR_TYPE_ENVIRONMENT_DEPTH_HAND_REMOVAL_SET_INFO_META) \ + _(XrSystemEnvironmentDepthPropertiesMETA, XR_TYPE_SYSTEM_ENVIRONMENT_DEPTH_PROPERTIES_META) \ + _(XrRenderModelCreateInfoEXT, XR_TYPE_RENDER_MODEL_CREATE_INFO_EXT) \ + _(XrRenderModelPropertiesGetInfoEXT, XR_TYPE_RENDER_MODEL_PROPERTIES_GET_INFO_EXT) \ + _(XrRenderModelPropertiesEXT, XR_TYPE_RENDER_MODEL_PROPERTIES_EXT) \ + _(XrRenderModelSpaceCreateInfoEXT, XR_TYPE_RENDER_MODEL_SPACE_CREATE_INFO_EXT) \ + _(XrRenderModelStateGetInfoEXT, XR_TYPE_RENDER_MODEL_STATE_GET_INFO_EXT) \ + _(XrRenderModelStateEXT, XR_TYPE_RENDER_MODEL_STATE_EXT) \ + _(XrRenderModelAssetCreateInfoEXT, XR_TYPE_RENDER_MODEL_ASSET_CREATE_INFO_EXT) \ + _(XrRenderModelAssetDataGetInfoEXT, XR_TYPE_RENDER_MODEL_ASSET_DATA_GET_INFO_EXT) \ + _(XrRenderModelAssetDataEXT, XR_TYPE_RENDER_MODEL_ASSET_DATA_EXT) \ + _(XrRenderModelAssetPropertiesGetInfoEXT, XR_TYPE_RENDER_MODEL_ASSET_PROPERTIES_GET_INFO_EXT) \ + _(XrRenderModelAssetPropertiesEXT, XR_TYPE_RENDER_MODEL_ASSET_PROPERTIES_EXT) \ + _(XrInteractionRenderModelIdsEnumerateInfoEXT, XR_TYPE_INTERACTION_RENDER_MODEL_IDS_ENUMERATE_INFO_EXT) \ + _(XrInteractionRenderModelSubactionPathInfoEXT, XR_TYPE_INTERACTION_RENDER_MODEL_SUBACTION_PATH_INFO_EXT) \ + _(XrInteractionRenderModelTopLevelUserPathGetInfoEXT, XR_TYPE_INTERACTION_RENDER_MODEL_TOP_LEVEL_USER_PATH_GET_INFO_EXT) \ + _(XrEventDataInteractionRenderModelsChangedEXT, XR_TYPE_EVENT_DATA_INTERACTION_RENDER_MODELS_CHANGED_EXT) \ + _(XrPassthroughCreateInfoHTC, XR_TYPE_PASSTHROUGH_CREATE_INFO_HTC) \ + _(XrPassthroughColorHTC, XR_TYPE_PASSTHROUGH_COLOR_HTC) \ + _(XrPassthroughMeshTransformInfoHTC, XR_TYPE_PASSTHROUGH_MESH_TRANSFORM_INFO_HTC) \ + _(XrCompositionLayerPassthroughHTC, XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_HTC) \ + _(XrFoveationApplyInfoHTC, XR_TYPE_FOVEATION_APPLY_INFO_HTC) \ + _(XrFoveationDynamicModeInfoHTC, XR_TYPE_FOVEATION_DYNAMIC_MODE_INFO_HTC) \ + _(XrFoveationCustomModeInfoHTC, XR_TYPE_FOVEATION_CUSTOM_MODE_INFO_HTC) \ + _(XrSystemAnchorPropertiesHTC, XR_TYPE_SYSTEM_ANCHOR_PROPERTIES_HTC) \ + _(XrSpatialAnchorCreateInfoHTC, XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_HTC) \ + _(XrSystemBodyTrackingPropertiesHTC, XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_HTC) \ + _(XrBodyTrackerCreateInfoHTC, XR_TYPE_BODY_TRACKER_CREATE_INFO_HTC) \ + _(XrBodyJointsLocateInfoHTC, XR_TYPE_BODY_JOINTS_LOCATE_INFO_HTC) \ + _(XrBodyJointLocationsHTC, XR_TYPE_BODY_JOINT_LOCATIONS_HTC) \ + _(XrBodySkeletonHTC, XR_TYPE_BODY_SKELETON_HTC) \ + _(XrActiveActionSetPrioritiesEXT, XR_TYPE_ACTIVE_ACTION_SET_PRIORITIES_EXT) \ + _(XrSystemForceFeedbackCurlPropertiesMNDX, XR_TYPE_SYSTEM_FORCE_FEEDBACK_CURL_PROPERTIES_MNDX) \ + _(XrForceFeedbackCurlApplyLocationsMNDX, XR_TYPE_FORCE_FEEDBACK_CURL_APPLY_LOCATIONS_MNDX) \ + _(XrSystemBodyTrackingPropertiesBD, XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_BD) \ + _(XrBodyTrackerCreateInfoBD, XR_TYPE_BODY_TRACKER_CREATE_INFO_BD) \ + _(XrBodyJointsLocateInfoBD, XR_TYPE_BODY_JOINTS_LOCATE_INFO_BD) \ + _(XrBodyJointLocationsBD, XR_TYPE_BODY_JOINT_LOCATIONS_BD) \ + _(XrSystemFacialSimulationPropertiesBD, XR_TYPE_SYSTEM_FACIAL_SIMULATION_PROPERTIES_BD) \ + _(XrFaceTrackerCreateInfoBD, XR_TYPE_FACE_TRACKER_CREATE_INFO_BD) \ + _(XrFacialSimulationDataGetInfoBD, XR_TYPE_FACIAL_SIMULATION_DATA_GET_INFO_BD) \ + _(XrFacialSimulationDataBD, XR_TYPE_FACIAL_SIMULATION_DATA_BD) \ + _(XrLipExpressionDataBD, XR_TYPE_LIP_EXPRESSION_DATA_BD) \ + _(XrSystemSpatialSensingPropertiesBD, XR_TYPE_SYSTEM_SPATIAL_SENSING_PROPERTIES_BD) \ + _(XrSpatialEntityComponentGetInfoBD, XR_TYPE_SPATIAL_ENTITY_COMPONENT_GET_INFO_BD) \ + _(XrSpatialEntityLocationGetInfoBD, XR_TYPE_SPATIAL_ENTITY_LOCATION_GET_INFO_BD) \ + _(XrSpatialEntityComponentDataLocationBD, XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_LOCATION_BD) \ + _(XrSpatialEntityComponentDataSemanticBD, XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_SEMANTIC_BD) \ + _(XrSpatialEntityComponentDataBoundingBox2DBD, XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_BOUNDING_BOX_2D_BD) \ + _(XrSpatialEntityComponentDataPolygonBD, XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_POLYGON_BD) \ + _(XrSpatialEntityComponentDataBoundingBox3DBD, XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_BOUNDING_BOX_3D_BD) \ + _(XrSpatialEntityComponentDataTriangleMeshBD, XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_TRIANGLE_MESH_BD) \ + _(XrSpatialEntityComponentDataSphereBD, XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_SPHERE_BD) \ + _(XrSenseDataProviderCreateInfoBD, XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_BD) \ + _(XrSenseDataProviderStartInfoBD, XR_TYPE_SENSE_DATA_PROVIDER_START_INFO_BD) \ + _(XrEventDataSenseDataProviderStateChangedBD, XR_TYPE_EVENT_DATA_SENSE_DATA_PROVIDER_STATE_CHANGED_BD) \ + _(XrEventDataSenseDataUpdatedBD, XR_TYPE_EVENT_DATA_SENSE_DATA_UPDATED_BD) \ + _(XrSenseDataQueryInfoBD, XR_TYPE_SENSE_DATA_QUERY_INFO_BD) \ + _(XrSenseDataQueryCompletionBD, XR_TYPE_SENSE_DATA_QUERY_COMPLETION_BD) \ + _(XrQueriedSenseDataGetInfoBD, XR_TYPE_QUERIED_SENSE_DATA_GET_INFO_BD) \ + _(XrSpatialEntityStateBD, XR_TYPE_SPATIAL_ENTITY_STATE_BD) \ + _(XrQueriedSenseDataBD, XR_TYPE_QUERIED_SENSE_DATA_BD) \ + _(XrSenseDataFilterUuidBD, XR_TYPE_SENSE_DATA_FILTER_UUID_BD) \ + _(XrSenseDataFilterSemanticBD, XR_TYPE_SENSE_DATA_FILTER_SEMANTIC_BD) \ + _(XrSpatialEntityAnchorCreateInfoBD, XR_TYPE_SPATIAL_ENTITY_ANCHOR_CREATE_INFO_BD) \ + _(XrAnchorSpaceCreateInfoBD, XR_TYPE_ANCHOR_SPACE_CREATE_INFO_BD) \ + _(XrFutureCompletionEXT, XR_TYPE_FUTURE_COMPLETION_EXT) \ + _(XrSystemSpatialAnchorPropertiesBD, XR_TYPE_SYSTEM_SPATIAL_ANCHOR_PROPERTIES_BD) \ + _(XrSpatialAnchorCreateInfoBD, XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_BD) \ + _(XrSpatialAnchorCreateCompletionBD, XR_TYPE_SPATIAL_ANCHOR_CREATE_COMPLETION_BD) \ + _(XrSpatialAnchorPersistInfoBD, XR_TYPE_SPATIAL_ANCHOR_PERSIST_INFO_BD) \ + _(XrSpatialAnchorUnpersistInfoBD, XR_TYPE_SPATIAL_ANCHOR_UNPERSIST_INFO_BD) \ + _(XrSystemSpatialAnchorSharingPropertiesBD, XR_TYPE_SYSTEM_SPATIAL_ANCHOR_SHARING_PROPERTIES_BD) \ + _(XrSpatialAnchorShareInfoBD, XR_TYPE_SPATIAL_ANCHOR_SHARE_INFO_BD) \ + _(XrSharedSpatialAnchorDownloadInfoBD, XR_TYPE_SHARED_SPATIAL_ANCHOR_DOWNLOAD_INFO_BD) \ + _(XrSystemSpatialScenePropertiesBD, XR_TYPE_SYSTEM_SPATIAL_SCENE_PROPERTIES_BD) \ + _(XrSceneCaptureInfoBD, XR_TYPE_SCENE_CAPTURE_INFO_BD) \ + _(XrSystemSpatialMeshPropertiesBD, XR_TYPE_SYSTEM_SPATIAL_MESH_PROPERTIES_BD) \ + _(XrSenseDataProviderCreateInfoSpatialMeshBD, XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_SPATIAL_MESH_BD) \ + _(XrFuturePollResultProgressBD, XR_TYPE_FUTURE_POLL_RESULT_PROGRESS_BD) \ + _(XrBodyTrackingPostureDataBD, XR_TYPE_BODY_TRACKING_POSTURE_DATA_BD) \ + _(XrBodyJointVelocitiesBD, XR_TYPE_BODY_JOINT_VELOCITIES_BD) \ + _(XrBodyJointAccelerationsBD, XR_TYPE_BODY_JOINT_ACCELERATIONS_BD) \ + _(XrBodyTrackingStateBD, XR_TYPE_BODY_TRACKING_STATE_BD) \ + _(XrSystemSpatialPlanePropertiesBD, XR_TYPE_SYSTEM_SPATIAL_PLANE_PROPERTIES_BD) \ + _(XrSpatialEntityComponentDataPlaneOrientationBD, XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_PLANE_ORIENTATION_BD) \ + _(XrSenseDataFilterPlaneOrientationBD, XR_TYPE_SENSE_DATA_FILTER_PLANE_ORIENTATION_BD) \ + _(XrSystemLightEstimationPropertiesBD, XR_TYPE_SYSTEM_LIGHT_ESTIMATION_PROPERTIES_BD) \ + _(XrSenseDataProviderCreateInfoLightEstimationBD, XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_LIGHT_ESTIMATION_BD) \ + _(XrEnvironmentTextureCreateConfigInfoBD, XR_TYPE_ENVIRONMENT_TEXTURE_CREATE_CONFIG_INFO_BD) \ + _(XrLightEstimationDataEnvironmentTextureRawBD, XR_TYPE_LIGHT_ESTIMATION_DATA_ENVIRONMENT_TEXTURE_RAW_BD) \ + _(XrLightEstimationDataSphericalHarmonicsBD, XR_TYPE_LIGHT_ESTIMATION_DATA_SPHERICAL_HARMONICS_BD) \ + _(XrSpatialEntityComponentDataLightEstimationBD, XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_LIGHT_ESTIMATION_BD) \ + _(XrSpatialAudioRendererCreateInfoBD, XR_TYPE_SPATIAL_AUDIO_RENDERER_CREATE_INFO_BD) \ + _(XrAudioBufferBD, XR_TYPE_AUDIO_BUFFER_BD) \ + _(XrSoundObjectDirectivityCardioidBD, XR_TYPE_SOUND_OBJECT_DIRECTIVITY_CARDIOID_BD) \ + _(XrSoundObjectShapeSphereBD, XR_TYPE_SOUND_OBJECT_SHAPE_SPHERE_BD) \ + _(XrSoundObjectDistanceAttenuationCurveBD, XR_TYPE_SOUND_OBJECT_DISTANCE_ATTENUATION_CURVE_BD) \ + _(XrSoundObjectDistanceAttenuationBD, XR_TYPE_SOUND_OBJECT_DISTANCE_ATTENUATION_BD) \ + _(XrSoundObjectConfigBD, XR_TYPE_SOUND_OBJECT_CONFIG_BD) \ + _(XrSoundFieldConfigBD, XR_TYPE_SOUND_FIELD_CONFIG_BD) \ + _(XrSoundFieldChannelDefinitionSurroundBD, XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_SURROUND_BD) \ + _(XrSoundFieldChannelDefinitionAmbixBD, XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_AMBIX_BD) \ + _(XrSoundFieldChannelDefinitionFumaBD, XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_FUMA_BD) \ + _(XrSoundTriangleMeshBD, XR_TYPE_SOUND_TRIANGLE_MESH_BD) \ + _(XrSoundObstacleConfigBD, XR_TYPE_SOUND_OBSTACLE_CONFIG_BD) \ + _(XrSoundObstacleMaterialConfigBD, XR_TYPE_SOUND_OBSTACLE_MATERIAL_CONFIG_BD) \ + _(XrHandTrackingDataSourceInfoEXT, XR_TYPE_HAND_TRACKING_DATA_SOURCE_INFO_EXT) \ + _(XrHandTrackingDataSourceStateEXT, XR_TYPE_HAND_TRACKING_DATA_SOURCE_STATE_EXT) \ + _(XrSystemPlaneDetectionPropertiesEXT, XR_TYPE_SYSTEM_PLANE_DETECTION_PROPERTIES_EXT) \ + _(XrPlaneDetectorCreateInfoEXT, XR_TYPE_PLANE_DETECTOR_CREATE_INFO_EXT) \ + _(XrPlaneDetectorBeginInfoEXT, XR_TYPE_PLANE_DETECTOR_BEGIN_INFO_EXT) \ + _(XrPlaneDetectorGetInfoEXT, XR_TYPE_PLANE_DETECTOR_GET_INFO_EXT) \ + _(XrPlaneDetectorLocationEXT, XR_TYPE_PLANE_DETECTOR_LOCATION_EXT) \ + _(XrPlaneDetectorLocationsEXT, XR_TYPE_PLANE_DETECTOR_LOCATIONS_EXT) \ + _(XrPlaneDetectorPolygonBufferEXT, XR_TYPE_PLANE_DETECTOR_POLYGON_BUFFER_EXT) \ + _(XrTrackableTrackerCreateInfoANDROID, XR_TYPE_TRACKABLE_TRACKER_CREATE_INFO_ANDROID) \ + _(XrTrackableGetInfoANDROID, XR_TYPE_TRACKABLE_GET_INFO_ANDROID) \ + _(XrTrackablePlaneANDROID, XR_TYPE_TRACKABLE_PLANE_ANDROID) \ + _(XrAnchorSpaceCreateInfoANDROID, XR_TYPE_ANCHOR_SPACE_CREATE_INFO_ANDROID) \ + _(XrSystemTrackablesPropertiesANDROID, XR_TYPE_SYSTEM_TRACKABLES_PROPERTIES_ANDROID) \ + _(XrSystemEyeTrackingPropertiesANDROID, XR_TYPE_SYSTEM_EYE_TRACKING_PROPERTIES_ANDROID) \ + _(XrEyesANDROID, XR_TYPE_EYES_ANDROID) \ + _(XrEyesGetInfoANDROID, XR_TYPE_EYES_GET_INFO_ANDROID) \ + _(XrEyeTrackerCreateInfoANDROID, XR_TYPE_EYE_TRACKER_CREATE_INFO_ANDROID) \ + _(XrDeviceAnchorPersistenceCreateInfoANDROID, XR_TYPE_DEVICE_ANCHOR_PERSISTENCE_CREATE_INFO_ANDROID) \ + _(XrPersistedAnchorSpaceCreateInfoANDROID, XR_TYPE_PERSISTED_ANCHOR_SPACE_CREATE_INFO_ANDROID) \ + _(XrPersistedAnchorSpaceInfoANDROID, XR_TYPE_PERSISTED_ANCHOR_SPACE_INFO_ANDROID) \ + _(XrSystemDeviceAnchorPersistencePropertiesANDROID, XR_TYPE_SYSTEM_DEVICE_ANCHOR_PERSISTENCE_PROPERTIES_ANDROID) \ + _(XrFaceTrackerCreateInfoANDROID, XR_TYPE_FACE_TRACKER_CREATE_INFO_ANDROID) \ + _(XrFaceStateGetInfoANDROID, XR_TYPE_FACE_STATE_GET_INFO_ANDROID) \ + _(XrFaceStateANDROID, XR_TYPE_FACE_STATE_ANDROID) \ + _(XrSystemFaceTrackingPropertiesANDROID, XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES_ANDROID) \ + _(XrSystemPassthroughCameraStatePropertiesANDROID, XR_TYPE_SYSTEM_PASSTHROUGH_CAMERA_STATE_PROPERTIES_ANDROID) \ + _(XrPassthroughCameraStateGetInfoANDROID, XR_TYPE_PASSTHROUGH_CAMERA_STATE_GET_INFO_ANDROID) \ + _(XrEventDataRecommendedResolutionChangedANDROID, XR_TYPE_EVENT_DATA_RECOMMENDED_RESOLUTION_CHANGED_ANDROID) \ + _(XrPassthroughLayerCreateInfoANDROID, XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_ANDROID) \ + _(XrPassthroughLayerMeshANDROID, XR_TYPE_PASSTHROUGH_LAYER_MESH_ANDROID) \ + _(XrCompositionLayerPassthroughANDROID, XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_ANDROID) \ + _(XrSystemPassthroughLayerPropertiesANDROID, XR_TYPE_SYSTEM_PASSTHROUGH_LAYER_PROPERTIES_ANDROID) \ + _(XrRaycastInfoANDROID, XR_TYPE_RAYCAST_INFO_ANDROID) \ + _(XrRaycastHitResultsANDROID, XR_TYPE_RAYCAST_HIT_RESULTS_ANDROID) \ + _(XrPerformanceMetricsStateANDROID, XR_TYPE_PERFORMANCE_METRICS_STATE_ANDROID) \ + _(XrPerformanceMetricsCounterANDROID, XR_TYPE_PERFORMANCE_METRICS_COUNTER_ANDROID) \ + _(XrTrackableObjectANDROID, XR_TYPE_TRACKABLE_OBJECT_ANDROID) \ + _(XrTrackableObjectConfigurationANDROID, XR_TYPE_TRACKABLE_OBJECT_CONFIGURATION_ANDROID) \ + _(XrFutureCancelInfoEXT, XR_TYPE_FUTURE_CANCEL_INFO_EXT) \ + _(XrFuturePollInfoEXT, XR_TYPE_FUTURE_POLL_INFO_EXT) \ + _(XrFuturePollResultEXT, XR_TYPE_FUTURE_POLL_RESULT_EXT) \ + _(XrEventDataUserPresenceChangedEXT, XR_TYPE_EVENT_DATA_USER_PRESENCE_CHANGED_EXT) \ + _(XrSystemUserPresencePropertiesEXT, XR_TYPE_SYSTEM_USER_PRESENCE_PROPERTIES_EXT) \ + _(XrEventDataHeadsetFitChangedML, XR_TYPE_EVENT_DATA_HEADSET_FIT_CHANGED_ML) \ + _(XrEventDataEyeCalibrationChangedML, XR_TYPE_EVENT_DATA_EYE_CALIBRATION_CHANGED_ML) \ + _(XrUserCalibrationEnableEventsInfoML, XR_TYPE_USER_CALIBRATION_ENABLE_EVENTS_INFO_ML) \ + _(XrSystemNotificationsSetInfoML, XR_TYPE_SYSTEM_NOTIFICATIONS_SET_INFO_ML) \ + _(XrWorldMeshDetectorCreateInfoML, XR_TYPE_WORLD_MESH_DETECTOR_CREATE_INFO_ML) \ + _(XrWorldMeshBlockStateML, XR_TYPE_WORLD_MESH_BLOCK_STATE_ML) \ + _(XrWorldMeshStateRequestInfoML, XR_TYPE_WORLD_MESH_STATE_REQUEST_INFO_ML) \ + _(XrWorldMeshStateRequestCompletionML, XR_TYPE_WORLD_MESH_STATE_REQUEST_COMPLETION_ML) \ + _(XrWorldMeshBufferRecommendedSizeInfoML, XR_TYPE_WORLD_MESH_BUFFER_RECOMMENDED_SIZE_INFO_ML) \ + _(XrWorldMeshBufferSizeML, XR_TYPE_WORLD_MESH_BUFFER_SIZE_ML) \ + _(XrWorldMeshBufferML, XR_TYPE_WORLD_MESH_BUFFER_ML) \ + _(XrWorldMeshBlockRequestML, XR_TYPE_WORLD_MESH_BLOCK_REQUEST_ML) \ + _(XrWorldMeshGetInfoML, XR_TYPE_WORLD_MESH_GET_INFO_ML) \ + _(XrWorldMeshBlockML, XR_TYPE_WORLD_MESH_BLOCK_ML) \ + _(XrWorldMeshRequestCompletionInfoML, XR_TYPE_WORLD_MESH_REQUEST_COMPLETION_INFO_ML) \ + _(XrWorldMeshRequestCompletionML, XR_TYPE_WORLD_MESH_REQUEST_COMPLETION_ML) \ + _(XrSystemFacialExpressionPropertiesML, XR_TYPE_SYSTEM_FACIAL_EXPRESSION_PROPERTIES_ML) \ + _(XrFacialExpressionClientCreateInfoML, XR_TYPE_FACIAL_EXPRESSION_CLIENT_CREATE_INFO_ML) \ + _(XrFacialExpressionBlendShapeGetInfoML, XR_TYPE_FACIAL_EXPRESSION_BLEND_SHAPE_GET_INFO_ML) \ + _(XrFacialExpressionBlendShapePropertiesML, XR_TYPE_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_ML) \ + _(XrSystemBoundaryVisibilityPropertiesMETA, XR_TYPE_SYSTEM_BOUNDARY_VISIBILITY_PROPERTIES_META) \ + _(XrEventDataBoundaryVisibilityChangedMETA, XR_TYPE_EVENT_DATA_BOUNDARY_VISIBILITY_CHANGED_META) \ + _(XrSystemSimultaneousHandsAndControllersPropertiesMETA, XR_TYPE_SYSTEM_SIMULTANEOUS_HANDS_AND_CONTROLLERS_PROPERTIES_META) \ + _(XrSimultaneousHandsAndControllersTrackingResumeInfoMETA, XR_TYPE_SIMULTANEOUS_HANDS_AND_CONTROLLERS_TRACKING_RESUME_INFO_META) \ + _(XrSimultaneousHandsAndControllersTrackingPauseInfoMETA, XR_TYPE_SIMULTANEOUS_HANDS_AND_CONTROLLERS_TRACKING_PAUSE_INFO_META) \ + _(XrFaceTrackingVisemesMETA, XR_TYPE_FACE_TRACKING_VISEMES_META) \ + _(XrSystemFaceTrackingVisemesPropertiesMETA, XR_TYPE_SYSTEM_FACE_TRACKING_VISEMES_PROPERTIES_META) \ + _(XrRoomMeshFaceIndicesMETA, XR_TYPE_ROOM_MESH_FACE_INDICES_META) \ + _(XrSpaceRoomMeshGetInfoMETA, XR_TYPE_SPACE_ROOM_MESH_GET_INFO_META) \ + _(XrRoomMeshMETA, XR_TYPE_ROOM_MESH_META) \ + _(XrColocationDiscoveryStartInfoMETA, XR_TYPE_COLOCATION_DISCOVERY_START_INFO_META) \ + _(XrColocationDiscoveryStopInfoMETA, XR_TYPE_COLOCATION_DISCOVERY_STOP_INFO_META) \ + _(XrColocationAdvertisementStartInfoMETA, XR_TYPE_COLOCATION_ADVERTISEMENT_START_INFO_META) \ + _(XrColocationAdvertisementStopInfoMETA, XR_TYPE_COLOCATION_ADVERTISEMENT_STOP_INFO_META) \ + _(XrEventDataStartColocationAdvertisementCompleteMETA, XR_TYPE_EVENT_DATA_START_COLOCATION_ADVERTISEMENT_COMPLETE_META) \ + _(XrEventDataStopColocationAdvertisementCompleteMETA, XR_TYPE_EVENT_DATA_STOP_COLOCATION_ADVERTISEMENT_COMPLETE_META) \ + _(XrEventDataColocationAdvertisementCompleteMETA, XR_TYPE_EVENT_DATA_COLOCATION_ADVERTISEMENT_COMPLETE_META) \ + _(XrEventDataStartColocationDiscoveryCompleteMETA, XR_TYPE_EVENT_DATA_START_COLOCATION_DISCOVERY_COMPLETE_META) \ + _(XrEventDataColocationDiscoveryResultMETA, XR_TYPE_EVENT_DATA_COLOCATION_DISCOVERY_RESULT_META) \ + _(XrEventDataColocationDiscoveryCompleteMETA, XR_TYPE_EVENT_DATA_COLOCATION_DISCOVERY_COMPLETE_META) \ + _(XrEventDataStopColocationDiscoveryCompleteMETA, XR_TYPE_EVENT_DATA_STOP_COLOCATION_DISCOVERY_COMPLETE_META) \ + _(XrSystemColocationDiscoveryPropertiesMETA, XR_TYPE_SYSTEM_COLOCATION_DISCOVERY_PROPERTIES_META) \ + _(XrSystemSpatialEntityGroupSharingPropertiesMETA, XR_TYPE_SYSTEM_SPATIAL_ENTITY_GROUP_SHARING_PROPERTIES_META) \ + _(XrShareSpacesRecipientGroupsMETA, XR_TYPE_SHARE_SPACES_RECIPIENT_GROUPS_META) \ + _(XrSpaceGroupUuidFilterInfoMETA, XR_TYPE_SPACE_GROUP_UUID_FILTER_INFO_META) \ + _(XrSystemEnvironmentRaycastPropertiesMETA, XR_TYPE_SYSTEM_ENVIRONMENT_RAYCAST_PROPERTIES_META) \ + _(XrEnvironmentRaycasterCreateInfoMETA, XR_TYPE_ENVIRONMENT_RAYCASTER_CREATE_INFO_META) \ + _(XrEnvironmentRaycasterCreateCompletionMETA, XR_TYPE_ENVIRONMENT_RAYCASTER_CREATE_COMPLETION_META) \ + _(XrEnvironmentRaycastHitGetInfoMETA, XR_TYPE_ENVIRONMENT_RAYCAST_HIT_GET_INFO_META) \ + _(XrEnvironmentRaycastHitMETA, XR_TYPE_ENVIRONMENT_RAYCAST_HIT_META) \ + _(XrEnvironmentRaycastFilterDistanceMETA, XR_TYPE_ENVIRONMENT_RAYCAST_FILTER_DISTANCE_META) \ + _(XrTilePropertiesMETA, XR_TYPE_TILE_PROPERTIES_META) \ + _(XrTilePropertiesHintMETA, XR_TYPE_TILE_PROPERTIES_HINT_META) \ + _(XrHandTrackingUnextrapolatedPosesRequestMETA, XR_TYPE_HAND_TRACKING_UNEXTRAPOLATED_POSES_REQUEST_META) \ + _(XrHandTrackingUnextrapolatedPosesMETA, XR_TYPE_HAND_TRACKING_UNEXTRAPOLATED_POSES_META) \ + _(XrSystemLightEstimationPropertiesANDROID, XR_TYPE_SYSTEM_LIGHT_ESTIMATION_PROPERTIES_ANDROID) \ + _(XrLightEstimatorCreateInfoANDROID, XR_TYPE_LIGHT_ESTIMATOR_CREATE_INFO_ANDROID) \ + _(XrLightEstimateGetInfoANDROID, XR_TYPE_LIGHT_ESTIMATE_GET_INFO_ANDROID) \ + _(XrLightEstimateANDROID, XR_TYPE_LIGHT_ESTIMATE_ANDROID) \ + _(XrDirectionalLightANDROID, XR_TYPE_DIRECTIONAL_LIGHT_ANDROID) \ + _(XrAmbientLightANDROID, XR_TYPE_AMBIENT_LIGHT_ANDROID) \ + _(XrSphericalHarmonicsANDROID, XR_TYPE_SPHERICAL_HARMONICS_ANDROID) \ + _(XrSystemMarkerTrackingPropertiesANDROID, XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_ANDROID) \ + _(XrTrackableMarkerConfigurationANDROID, XR_TYPE_TRACKABLE_MARKER_CONFIGURATION_ANDROID) \ + _(XrTrackableMarkerANDROID, XR_TYPE_TRACKABLE_MARKER_ANDROID) \ + _(XrSystemQrCodeTrackingPropertiesANDROID, XR_TYPE_SYSTEM_QR_CODE_TRACKING_PROPERTIES_ANDROID) \ + _(XrTrackableQrCodeConfigurationANDROID, XR_TYPE_TRACKABLE_QR_CODE_CONFIGURATION_ANDROID) \ + _(XrTrackableQrCodeANDROID, XR_TYPE_TRACKABLE_QR_CODE_ANDROID) \ + _(XrSystemImageTrackingPropertiesANDROID, XR_TYPE_SYSTEM_IMAGE_TRACKING_PROPERTIES_ANDROID) \ + _(XrTrackableImageDatabaseEntryANDROID, XR_TYPE_TRACKABLE_IMAGE_DATABASE_ENTRY_ANDROID) \ + _(XrTrackableImageDatabaseCreateInfoANDROID, XR_TYPE_TRACKABLE_IMAGE_DATABASE_CREATE_INFO_ANDROID) \ + _(XrCreateTrackableImageDatabaseCompletionANDROID, XR_TYPE_CREATE_TRACKABLE_IMAGE_DATABASE_COMPLETION_ANDROID) \ + _(XrTrackableImageConfigurationANDROID, XR_TYPE_TRACKABLE_IMAGE_CONFIGURATION_ANDROID) \ + _(XrTrackableImageANDROID, XR_TYPE_TRACKABLE_IMAGE_ANDROID) \ + _(XrEventDataImageTrackingLostANDROID, XR_TYPE_EVENT_DATA_IMAGE_TRACKING_LOST_ANDROID) \ + _(XrSystemSceneMeshingPropertiesANDROID, XR_TYPE_SYSTEM_SCENE_MESHING_PROPERTIES_ANDROID) \ + _(XrSceneMeshingTrackerCreateInfoANDROID, XR_TYPE_SCENE_MESHING_TRACKER_CREATE_INFO_ANDROID) \ + _(XrSceneMeshSnapshotCreateInfoANDROID, XR_TYPE_SCENE_MESH_SNAPSHOT_CREATE_INFO_ANDROID) \ + _(XrSceneMeshSnapshotCreationResultANDROID, XR_TYPE_SCENE_MESH_SNAPSHOT_CREATION_RESULT_ANDROID) \ + _(XrSceneSubmeshStateANDROID, XR_TYPE_SCENE_SUBMESH_STATE_ANDROID) \ + _(XrSceneSubmeshDataANDROID, XR_TYPE_SCENE_SUBMESH_DATA_ANDROID) \ + _(XrSpatialCapabilityComponentTypesEXT, XR_TYPE_SPATIAL_CAPABILITY_COMPONENT_TYPES_EXT) \ + _(XrSpatialContextCreateInfoEXT, XR_TYPE_SPATIAL_CONTEXT_CREATE_INFO_EXT) \ + _(XrCreateSpatialContextCompletionEXT, XR_TYPE_CREATE_SPATIAL_CONTEXT_COMPLETION_EXT) \ + _(XrSpatialDiscoverySnapshotCreateInfoEXT, XR_TYPE_SPATIAL_DISCOVERY_SNAPSHOT_CREATE_INFO_EXT) \ + _(XrCreateSpatialDiscoverySnapshotCompletionInfoEXT, XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_INFO_EXT) \ + _(XrCreateSpatialDiscoverySnapshotCompletionEXT, XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_EXT) \ + _(XrSpatialComponentDataQueryConditionEXT, XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_CONDITION_EXT) \ + _(XrSpatialComponentDataQueryResultEXT, XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_RESULT_EXT) \ + _(XrSpatialBufferGetInfoEXT, XR_TYPE_SPATIAL_BUFFER_GET_INFO_EXT) \ + _(XrSpatialComponentBounded2DListEXT, XR_TYPE_SPATIAL_COMPONENT_BOUNDED_2D_LIST_EXT) \ + _(XrSpatialComponentBounded3DListEXT, XR_TYPE_SPATIAL_COMPONENT_BOUNDED_3D_LIST_EXT) \ + _(XrSpatialComponentParentListEXT, XR_TYPE_SPATIAL_COMPONENT_PARENT_LIST_EXT) \ + _(XrSpatialComponentMesh3DListEXT, XR_TYPE_SPATIAL_COMPONENT_MESH_3D_LIST_EXT) \ + _(XrSpatialEntityFromIdCreateInfoEXT, XR_TYPE_SPATIAL_ENTITY_FROM_ID_CREATE_INFO_EXT) \ + _(XrSpatialUpdateSnapshotCreateInfoEXT, XR_TYPE_SPATIAL_UPDATE_SNAPSHOT_CREATE_INFO_EXT) \ + _(XrEventDataSpatialDiscoveryRecommendedEXT, XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT) \ + _(XrSpatialFilterTrackingStateEXT, XR_TYPE_SPATIAL_FILTER_TRACKING_STATE_EXT) \ + _(XrSpatialCapabilityConfigurationPlaneTrackingEXT, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_PLANE_TRACKING_EXT) \ + _(XrSpatialComponentPlaneAlignmentListEXT, XR_TYPE_SPATIAL_COMPONENT_PLANE_ALIGNMENT_LIST_EXT) \ + _(XrSpatialComponentMesh2DListEXT, XR_TYPE_SPATIAL_COMPONENT_MESH_2D_LIST_EXT) \ + _(XrSpatialComponentPolygon2DListEXT, XR_TYPE_SPATIAL_COMPONENT_POLYGON_2D_LIST_EXT) \ + _(XrSpatialComponentPlaneSemanticLabelListEXT, XR_TYPE_SPATIAL_COMPONENT_PLANE_SEMANTIC_LABEL_LIST_EXT) \ + _(XrStationaryReferenceSpaceGenerationIdGetInfoEXT, XR_TYPE_STATIONARY_REFERENCE_SPACE_GENERATION_ID_GET_INFO_EXT) \ + _(XrStationaryReferenceSpaceGenerationIdResultEXT, XR_TYPE_STATIONARY_REFERENCE_SPACE_GENERATION_ID_RESULT_EXT) \ + _(XrSpatialCapabilityConfigurationQrCodeEXT, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_QR_CODE_EXT) \ + _(XrSpatialCapabilityConfigurationMicroQrCodeEXT, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_MICRO_QR_CODE_EXT) \ + _(XrSpatialCapabilityConfigurationArucoMarkerEXT, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ARUCO_MARKER_EXT) \ + _(XrSpatialCapabilityConfigurationAprilTagEXT, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_APRIL_TAG_EXT) \ + _(XrSpatialMarkerSizeEXT, XR_TYPE_SPATIAL_MARKER_SIZE_EXT) \ + _(XrSpatialMarkerStaticOptimizationEXT, XR_TYPE_SPATIAL_MARKER_STATIC_OPTIMIZATION_EXT) \ + _(XrSpatialComponentMarkerListEXT, XR_TYPE_SPATIAL_COMPONENT_MARKER_LIST_EXT) \ + _(XrSystemDynamicObjectTrackingPropertiesBD, XR_TYPE_SYSTEM_DYNAMIC_OBJECT_TRACKING_PROPERTIES_BD) \ + _(XrSenseDataProviderCreateInfoDynamicObjectBD, XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_DYNAMIC_OBJECT_BD) \ + _(XrDynamicObjectDataBD, XR_TYPE_DYNAMIC_OBJECT_DATA_BD) \ + _(XrSpatialEntityComponentDataDynamicObjectBD, XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_DYNAMIC_OBJECT_BD) \ + _(XrSenseDataFilterDynamicObjectTypeBD, XR_TYPE_SENSE_DATA_FILTER_DYNAMIC_OBJECT_TYPE_BD) \ + _(XrSystemDynamicObjectKeyboardPropertiesBD, XR_TYPE_SYSTEM_DYNAMIC_OBJECT_KEYBOARD_PROPERTIES_BD) \ + _(XrSystemDynamicObjectMousePropertiesBD, XR_TYPE_SYSTEM_DYNAMIC_OBJECT_MOUSE_PROPERTIES_BD) \ + _(XrCameraPropertiesBD, XR_TYPE_CAMERA_PROPERTIES_BD) \ + _(XrCameraCapabilitiesBD, XR_TYPE_CAMERA_CAPABILITIES_BD) \ + _(XrAvailableCamerasEnumerateInfoBD, XR_TYPE_AVAILABLE_CAMERAS_ENUMERATE_INFO_BD) \ + _(XrAvailableCameraBD, XR_TYPE_AVAILABLE_CAMERA_BD) \ + _(XrCameraPropertyTypesEnumerateInfoBD, XR_TYPE_CAMERA_PROPERTY_TYPES_ENUMERATE_INFO_BD) \ + _(XrCameraPropertyTypesBD, XR_TYPE_CAMERA_PROPERTY_TYPES_BD) \ + _(XrCameraPropertiesGetInfoBD, XR_TYPE_CAMERA_PROPERTIES_GET_INFO_BD) \ + _(XrCameraPropertyFacingBD, XR_TYPE_CAMERA_PROPERTY_FACING_BD) \ + _(XrCameraPropertyPositionBD, XR_TYPE_CAMERA_PROPERTY_POSITION_BD) \ + _(XrCameraPropertyCameraTypeBD, XR_TYPE_CAMERA_PROPERTY_CAMERA_TYPE_BD) \ + _(XrCameraCapabilityTypesEnumerateInfoBD, XR_TYPE_CAMERA_CAPABILITY_TYPES_ENUMERATE_INFO_BD) \ + _(XrCameraCapabilityTypesBD, XR_TYPE_CAMERA_CAPABILITY_TYPES_BD) \ + _(XrCameraSupportedCapabilitiesGetInfoBD, XR_TYPE_CAMERA_SUPPORTED_CAPABILITIES_GET_INFO_BD) \ + _(XrCameraSupportedCapabilitiesBD, XR_TYPE_CAMERA_SUPPORTED_CAPABILITIES_BD) \ + _(XrCameraSupportedCapabilityImageResolutionAndFrameRateBD, XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_IMAGE_RESOLUTION_AND_FRAME_RATE_BD) \ + _(XrCameraCapabilityImageResolutionAndFrameRateBD, XR_TYPE_CAMERA_CAPABILITY_IMAGE_RESOLUTION_AND_FRAME_RATE_BD) \ + _(XrCameraSupportedCapabilityDataTransferTypeBD, XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_DATA_TRANSFER_TYPE_BD) \ + _(XrCameraCapabilityDataTransferTypeBD, XR_TYPE_CAMERA_CAPABILITY_DATA_TRANSFER_TYPE_BD) \ + _(XrCameraSupportedCapabilityImageFormatBD, XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_IMAGE_FORMAT_BD) \ + _(XrCameraCapabilityImageFormatBD, XR_TYPE_CAMERA_CAPABILITY_IMAGE_FORMAT_BD) \ + _(XrCameraSupportedCapabilityCameraModelBD, XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_CAMERA_MODEL_BD) \ + _(XrCameraCapabilityCameraModelBD, XR_TYPE_CAMERA_CAPABILITY_CAMERA_MODEL_BD) \ + _(XrCameraDeviceCreateInfoBD, XR_TYPE_CAMERA_DEVICE_CREATE_INFO_BD) \ + _(XrCreateCameraDeviceCompletionBD, XR_TYPE_CREATE_CAMERA_DEVICE_COMPLETION_BD) \ + _(XrCameraCaptureSessionCreateInfoBD, XR_TYPE_CAMERA_CAPTURE_SESSION_CREATE_INFO_BD) \ + _(XrCreateCameraCaptureSessionCompletionBD, XR_TYPE_CREATE_CAMERA_CAPTURE_SESSION_COMPLETION_BD) \ + _(XrCameraIntrinsicsBD, XR_TYPE_CAMERA_INTRINSICS_BD) \ + _(XrCameraExtrinsicsBD, XR_TYPE_CAMERA_EXTRINSICS_BD) \ + _(XrCameraCaptureBeginInfoBD, XR_TYPE_CAMERA_CAPTURE_BEGIN_INFO_BD) \ + _(XrCameraImageAcquireInfoBD, XR_TYPE_CAMERA_IMAGE_ACQUIRE_INFO_BD) \ + _(XrCameraImageBD, XR_TYPE_CAMERA_IMAGE_BD) \ + _(XrCameraImageDataRawBufferBD, XR_TYPE_CAMERA_IMAGE_DATA_RAW_BUFFER_BD) \ + _(XrSpatialBoundsSpherefANDROID, XR_TYPE_SPATIAL_BOUNDS_SPHEREF_ANDROID) \ + _(XrSpatialBoundsBoxfANDROID, XR_TYPE_SPATIAL_BOUNDS_BOXF_ANDROID) \ + _(XrSpatialBoundsFrustumfANDROID, XR_TYPE_SPATIAL_BOUNDS_FRUSTUMF_ANDROID) \ + _(XrSpatialCapabilityConfigurationAnchorEXT, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ANCHOR_EXT) \ + _(XrSpatialComponentAnchorListEXT, XR_TYPE_SPATIAL_COMPONENT_ANCHOR_LIST_EXT) \ + _(XrSpatialAnchorCreateInfoEXT, XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_EXT) \ + _(XrSpatialPersistenceContextCreateInfoEXT, XR_TYPE_SPATIAL_PERSISTENCE_CONTEXT_CREATE_INFO_EXT) \ + _(XrCreateSpatialPersistenceContextCompletionEXT, XR_TYPE_CREATE_SPATIAL_PERSISTENCE_CONTEXT_COMPLETION_EXT) \ + _(XrSpatialContextPersistenceConfigEXT, XR_TYPE_SPATIAL_CONTEXT_PERSISTENCE_CONFIG_EXT) \ + _(XrSpatialDiscoveryPersistenceUuidFilterEXT, XR_TYPE_SPATIAL_DISCOVERY_PERSISTENCE_UUID_FILTER_EXT) \ + _(XrSpatialComponentPersistenceListEXT, XR_TYPE_SPATIAL_COMPONENT_PERSISTENCE_LIST_EXT) \ + _(XrHapticParametricPropertiesEXT, XR_TYPE_HAPTIC_PARAMETRIC_PROPERTIES_EXT) \ + _(XrHapticParametricVibrationEXT, XR_TYPE_HAPTIC_PARAMETRIC_VIBRATION_EXT) \ + _(XrSystemHapticParametricPropertiesEXT, XR_TYPE_SYSTEM_HAPTIC_PARAMETRIC_PROPERTIES_EXT) \ + _(XrColorSpacesEnumerateInfoSONY, XR_TYPE_COLOR_SPACES_ENUMERATE_INFO_SONY) \ + _(XrSwapchainCreateInfoColorSpaceSONY, XR_TYPE_SWAPCHAIN_CREATE_INFO_COLOR_SPACE_SONY) \ + _(XrHdrMetadataSONY, XR_TYPE_HDR_METADATA_SONY) \ + _(XrSpatialEntityPersistInfoEXT, XR_TYPE_SPATIAL_ENTITY_PERSIST_INFO_EXT) \ + _(XrPersistSpatialEntityCompletionEXT, XR_TYPE_PERSIST_SPATIAL_ENTITY_COMPLETION_EXT) \ + _(XrSpatialEntityUnpersistInfoEXT, XR_TYPE_SPATIAL_ENTITY_UNPERSIST_INFO_EXT) \ + _(XrUnpersistSpatialEntityCompletionEXT, XR_TYPE_UNPERSIST_SPATIAL_ENTITY_COMPLETION_EXT) \ + _(XrSpatialReferenceImageEXT, XR_TYPE_SPATIAL_REFERENCE_IMAGE_EXT) \ + _(XrSpatialImageStaticOptimizationEXT, XR_TYPE_SPATIAL_IMAGE_STATIC_OPTIMIZATION_EXT) \ + _(XrSpatialImageSizeEXT, XR_TYPE_SPATIAL_IMAGE_SIZE_EXT) \ + _(XrSpatialCapabilityConfigurationImageTrackingEXT, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_IMAGE_TRACKING_EXT) \ + _(XrSpatialImageTrackingDatabaseCreateInfoEXT, XR_TYPE_SPATIAL_IMAGE_TRACKING_DATABASE_CREATE_INFO_EXT) \ + _(XrSpatialComponentImage2DListEXT, XR_TYPE_SPATIAL_COMPONENT_IMAGE_2D_LIST_EXT) \ + _(XrCreateSpatialImageTrackingDatabaseCompletionEXT, XR_TYPE_CREATE_SPATIAL_IMAGE_TRACKING_DATABASE_COMPLETION_EXT) \ + _(XrSpatialCapabilityConfigurationObjectTrackingANDROID, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_OBJECT_TRACKING_ANDROID) \ + _(XrSpatialComponentObjectSemanticLabelListANDROID, XR_TYPE_SPATIAL_COMPONENT_OBJECT_SEMANTIC_LABEL_LIST_ANDROID) \ + _(XrSpatialCapabilityConfigurationDepthRaycastANDROID, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_DEPTH_RAYCAST_ANDROID) \ + _(XrSpatialRaycastInfoANDROID, XR_TYPE_SPATIAL_RAYCAST_INFO_ANDROID) \ + _(XrSpatialComponentRaycastResultListANDROID, XR_TYPE_SPATIAL_COMPONENT_RAYCAST_RESULT_LIST_ANDROID) \ + _(XrSpatialRaycastSnapshotCreateInfoANDROID, XR_TYPE_SPATIAL_RAYCAST_SNAPSHOT_CREATE_INFO_ANDROID) \ + _(XrGoogleCloudAuthInfoApiKeyANDROID, XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_API_KEY_ANDROID) \ + _(XrGoogleCloudAuthInfoTokenANDROID, XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_TOKEN_ANDROID) \ + _(XrGoogleCloudAuthInfoKeylessANDROID, XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_KEYLESS_ANDROID) \ + _(XrGoogleCloudAuthErrorResultANDROID, XR_TYPE_GOOGLE_CLOUD_AUTH_ERROR_RESULT_ANDROID) \ + _(XrSystemGeospatialPropertiesANDROID, XR_TYPE_SYSTEM_GEOSPATIAL_PROPERTIES_ANDROID) \ + _(XrGeospatialTrackerCreateInfoANDROID, XR_TYPE_GEOSPATIAL_TRACKER_CREATE_INFO_ANDROID) \ + _(XrEventDataGeospatialTrackerStateChangedANDROID, XR_TYPE_EVENT_DATA_GEOSPATIAL_TRACKER_STATE_CHANGED_ANDROID) \ + _(XrGeospatialPoseFromPoseLocateInfoANDROID, XR_TYPE_GEOSPATIAL_POSE_FROM_POSE_LOCATE_INFO_ANDROID) \ + _(XrGeospatialPoseResultANDROID, XR_TYPE_GEOSPATIAL_POSE_RESULT_ANDROID) \ + _(XrGeospatialPoseLocateInfoANDROID, XR_TYPE_GEOSPATIAL_POSE_LOCATE_INFO_ANDROID) \ + _(XrVPSAvailabilityCheckCompletionANDROID, XR_TYPE_VPS_AVAILABILITY_CHECK_COMPLETION_ANDROID) \ + _(XrSpatialAnchorParentANDROID, XR_TYPE_SPATIAL_ANCHOR_PARENT_ANDROID) \ + _(XrSpatialDiscoveryUniqueEntitiesFilterANDROID, XR_TYPE_SPATIAL_DISCOVERY_UNIQUE_ENTITIES_FILTER_ANDROID) \ + _(XrSpatialComponentSubsumedByListANDROID, XR_TYPE_SPATIAL_COMPONENT_SUBSUMED_BY_LIST_ANDROID) \ + _(XrSpatialAnchorSpaceFromIdCreateInfoANDROID, XR_TYPE_SPATIAL_ANCHOR_SPACE_FROM_ID_CREATE_INFO_ANDROID) \ + _(XrSystemGeospatialAnchorPropertiesANDROID, XR_TYPE_SYSTEM_GEOSPATIAL_ANCHOR_PROPERTIES_ANDROID) \ + _(XrGeospatialTrackerAnchorTrackingInfoANDROID, XR_TYPE_GEOSPATIAL_TRACKER_ANCHOR_TRACKING_INFO_ANDROID) \ + _(XrGeospatialAnchorCreateInfoANDROID, XR_TYPE_GEOSPATIAL_ANCHOR_CREATE_INFO_ANDROID) \ + _(XrSurfaceAnchorCreateInfoANDROID, XR_TYPE_SURFACE_ANCHOR_CREATE_INFO_ANDROID) \ + _(XrSurfaceAnchorCreateCompletionANDROID, XR_TYPE_SURFACE_ANCHOR_CREATE_COMPLETION_ANDROID) \ + _(XrSessionCreateInfoSpatialContainersEXT, XR_TYPE_SESSION_CREATE_INFO_SPATIAL_CONTAINERS_EXT) \ + _(XrSpatialContainerCreateInfoEXT, XR_TYPE_SPATIAL_CONTAINER_CREATE_INFO_EXT) \ + _(XrSpatialContainerSpaceCreateInfoEXT, XR_TYPE_SPATIAL_CONTAINER_SPACE_CREATE_INFO_EXT) \ + _(XrEventDataSpatialContainerClosedEXT, XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_CLOSED_EXT) \ + _(XrSystemSpatialContainerPropertiesEXT, XR_TYPE_SYSTEM_SPATIAL_CONTAINER_PROPERTIES_EXT) \ + _(XrSpatialContainerBoundsEXT, XR_TYPE_SPATIAL_CONTAINER_BOUNDS_EXT) \ + _(XrEventDataSpatialContainerBoundsChangedEXT, XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_BOUNDS_CHANGED_EXT) \ + _(XrSpatialContainerBoundsGetInfoEXT, XR_TYPE_SPATIAL_CONTAINER_BOUNDS_GET_INFO_EXT) \ + _(XrSpatialContainerStateGetInfoEXT, XR_TYPE_SPATIAL_CONTAINER_STATE_GET_INFO_EXT) \ + _(XrSpatialContainerVisibleRequestInfoEXT, XR_TYPE_SPATIAL_CONTAINER_VISIBLE_REQUEST_INFO_EXT) \ + _(XrEventDataSpatialContainerVisibleChangedEXT, XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_VISIBLE_CHANGED_EXT) \ + _(XrEventDataSpatialContainerVisibleRequestDeniedEXT, XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_VISIBLE_REQUEST_DENIED_EXT) \ + _(XrEventDataSpatialContainerInteractableChangedEXT, XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_INTERACTABLE_CHANGED_EXT) \ + _(XrSpatialContainerBoundsModeRequestInfoEXT, XR_TYPE_SPATIAL_CONTAINER_BOUNDS_MODE_REQUEST_INFO_EXT) \ + _(XrEventDataSpatialContainerBoundsModeRequestDeniedEXT, XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_BOUNDS_MODE_REQUEST_DENIED_EXT) \ + _(XrSpatialContainerStateEXT, XR_TYPE_SPATIAL_CONTAINER_STATE_EXT) \ + _(XrSpatialContainerViewLocateInfoEXT, XR_TYPE_SPATIAL_CONTAINER_VIEW_LOCATE_INFO_EXT) \ + _(XrSpatialContainerViewsLocateInfoEXT, XR_TYPE_SPATIAL_CONTAINER_VIEWS_LOCATE_INFO_EXT) \ + _(XrSpatialContainerViewStateEXT, XR_TYPE_SPATIAL_CONTAINER_VIEW_STATE_EXT) \ + _(XrSpatialContainerLayerEXT, XR_TYPE_SPATIAL_CONTAINER_LAYER_EXT) \ + _(XrSpatialContainerLayerFrameEndInfoEXT, XR_TYPE_SPATIAL_CONTAINER_LAYER_FRAME_END_INFO_EXT) \ + _(XrSpatialContainerBeginInfoEXT, XR_TYPE_SPATIAL_CONTAINER_BEGIN_INFO_EXT) \ + _(XrSpatialContainerEndInfoEXT, XR_TYPE_SPATIAL_CONTAINER_END_INFO_EXT) \ + _(XrSpatialContainerCompositionLayerViewConfigurationEXT, XR_TYPE_SPATIAL_CONTAINER_COMPOSITION_LAYER_VIEW_CONFIGURATION_EXT) \ + _(XrSpatialContainerLayerVolumeClippingEXT, XR_TYPE_SPATIAL_CONTAINER_LAYER_VOLUME_CLIPPING_EXT) \ + _(XrBatteryStateDisplayEXT, XR_TYPE_BATTERY_STATE_DISPLAY_EXT) \ + _(XrLoaderInitInfoPropertiesEXT, XR_TYPE_LOADER_INIT_INFO_PROPERTIES_EXT) \ + _(XrEventDataViewConfigurationViewsChangedEXT, XR_TYPE_EVENT_DATA_VIEW_CONFIGURATION_VIEWS_CHANGED_EXT) \ + + +#if defined(XR_USE_GRAPHICS_API_D3D11) +/// Implementation detail of XR_LIST_STRUCTURE_TYPES() +/// Structure types available only when XR_USE_GRAPHICS_API_D3D11 is defined +#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) +/// Implementation detail of XR_LIST_STRUCTURE_TYPES() +/// Structure types available only when XR_USE_GRAPHICS_API_D3D12 is defined +#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_METAL) +/// Implementation detail of XR_LIST_STRUCTURE_TYPES() +/// Structure types available only when XR_USE_GRAPHICS_API_METAL is defined +#define XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_METAL(_) \ + _(XrGraphicsBindingMetalKHR, XR_TYPE_GRAPHICS_BINDING_METAL_KHR) \ + _(XrSwapchainImageMetalKHR, XR_TYPE_SWAPCHAIN_IMAGE_METAL_KHR) \ + _(XrGraphicsRequirementsMetalKHR, XR_TYPE_GRAPHICS_REQUIREMENTS_METAL_KHR) \ + +#else +#define XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_METAL(_) +#endif + +#if defined(XR_USE_GRAPHICS_API_OPENGL) +/// Implementation detail of XR_LIST_STRUCTURE_TYPES() +/// Structure types available only when XR_USE_GRAPHICS_API_OPENGL is defined +#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) +/// Implementation detail of XR_LIST_STRUCTURE_TYPES() +/// Structure types available only when XR_USE_GRAPHICS_API_OPENGL and XR_USE_PLATFORM_WAYLAND are defined +#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) +/// Implementation detail of XR_LIST_STRUCTURE_TYPES() +/// Structure types available only when XR_USE_GRAPHICS_API_OPENGL and XR_USE_PLATFORM_WIN32 are defined +#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) +/// Implementation detail of XR_LIST_STRUCTURE_TYPES() +/// Structure types available only when XR_USE_GRAPHICS_API_OPENGL and XR_USE_PLATFORM_XCB are defined +#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) +/// Implementation detail of XR_LIST_STRUCTURE_TYPES() +/// Structure types available only when XR_USE_GRAPHICS_API_OPENGL and XR_USE_PLATFORM_XLIB are defined +#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) +/// Implementation detail of XR_LIST_STRUCTURE_TYPES() +/// Structure types available only when XR_USE_GRAPHICS_API_OPENGL_ES is defined +#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) +/// Implementation detail of XR_LIST_STRUCTURE_TYPES() +/// Structure types available only when XR_USE_GRAPHICS_API_OPENGL_ES and XR_USE_PLATFORM_ANDROID are defined +#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) +/// Implementation detail of XR_LIST_STRUCTURE_TYPES() +/// Structure types available only when XR_USE_GRAPHICS_API_VULKAN is defined +#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) \ + _(XrVulkanSwapchainCreateInfoMETA, XR_TYPE_VULKAN_SWAPCHAIN_CREATE_INFO_META) \ + +#else +#define XR_LIST_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_VULKAN(_) +#endif + +#if defined(XR_USE_PLATFORM_ANDROID) +/// Implementation detail of XR_LIST_STRUCTURE_TYPES() +/// Structure types available only when XR_USE_PLATFORM_ANDROID is defined +#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) \ + _(XrAnchorSharingInfoANDROID, XR_TYPE_ANCHOR_SHARING_INFO_ANDROID) \ + _(XrAnchorSharingTokenANDROID, XR_TYPE_ANCHOR_SHARING_TOKEN_ANDROID) \ + _(XrSystemAnchorSharingExportPropertiesANDROID, XR_TYPE_SYSTEM_ANCHOR_SHARING_EXPORT_PROPERTIES_ANDROID) \ + +#else +#define XR_LIST_STRUCTURE_TYPES_XR_USE_PLATFORM_ANDROID(_) +#endif + +#if defined(XR_USE_PLATFORM_EGL) +/// Implementation detail of XR_LIST_STRUCTURE_TYPES() +/// Structure types available only when XR_USE_PLATFORM_EGL is defined +#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_ML) +/// Implementation detail of XR_LIST_STRUCTURE_TYPES() +/// Structure types available only when XR_USE_PLATFORM_ML is defined +#define XR_LIST_STRUCTURE_TYPES_XR_USE_PLATFORM_ML(_) \ + _(XrCoordinateSpaceCreateInfoML, XR_TYPE_COORDINATE_SPACE_CREATE_INFO_ML) \ + +#else +#define XR_LIST_STRUCTURE_TYPES_XR_USE_PLATFORM_ML(_) +#endif + +#if defined(XR_USE_PLATFORM_WIN32) +/// Implementation detail of XR_LIST_STRUCTURE_TYPES() +/// Structure types available only when XR_USE_PLATFORM_WIN32 is defined +#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 + + + +/// Calls your macro with the name and extension number of all known +/// extensions in this version of the spec. +#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_KHR_metal_enable, 30) \ + _(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_FB_body_tracking, 77) \ + _(XR_EXT_dpad_binding, 79) \ + _(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_HTC_hand_interaction, 107) \ + _(XR_HTC_vive_wrist_tracker_interaction, 108) \ + _(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_spatial_entity, 114) \ + _(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_VARJO_view_offset, 126) \ + _(XR_VARJO_xr4_controller_interaction, 130) \ + _(XR_ML_ml2_controller_interaction, 135) \ + _(XR_ML_frame_end_info, 136) \ + _(XR_ML_global_dimmer, 137) \ + _(XR_ML_compat, 138) \ + _(XR_ML_marker_understanding, 139) \ + _(XR_ML_localization_map, 140) \ + _(XR_ML_spatial_anchors, 141) \ + _(XR_ML_spatial_anchors_storage, 142) \ + _(XR_MSFT_spatial_anchor_persistence, 143) \ + _(XR_MSFT_scene_marker, 148) \ + _(XR_KHR_extended_struct_name_lengths, 149) \ + _(XR_ULTRALEAP_hand_tracking_forearm, 150) \ + _(XR_FB_spatial_entity_query, 157) \ + _(XR_FB_spatial_entity_storage, 159) \ + _(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_touch_controller_pro, 168) \ + _(XR_FB_spatial_entity_sharing, 170) \ + _(XR_FB_space_warp, 172) \ + _(XR_FB_haptic_amplitude_envelope, 174) \ + _(XR_FB_scene, 176) \ + _(XR_EXT_palm_pose, 177) \ + _(XR_ALMALENCE_digital_lens_control, 197) \ + _(XR_FB_scene_capture, 199) \ + _(XR_FB_spatial_entity_container, 200) \ + _(XR_META_foveation_eye_tracked, 201) \ + _(XR_FB_face_tracking, 202) \ + _(XR_FB_eye_tracking_social, 203) \ + _(XR_FB_passthrough_keyboard_hands, 204) \ + _(XR_FB_composition_layer_settings, 205) \ + _(XR_FB_touch_controller_proximity, 207) \ + _(XR_FB_haptic_pcm, 210) \ + _(XR_EXT_frame_synthesis, 212) \ + _(XR_FB_composition_layer_depth_test, 213) \ + _(XR_META_local_dimming, 217) \ + _(XR_META_passthrough_preferences, 218) \ + _(XR_META_virtual_keyboard, 220) \ + _(XR_OCULUS_external_camera, 227) \ + _(XR_META_vulkan_swapchain_create_info, 228) \ + _(XR_META_performance_metrics, 233) \ + _(XR_FB_spatial_entity_storage_batch, 239) \ + _(XR_META_detached_controllers, 241) \ + _(XR_FB_spatial_entity_user, 242) \ + _(XR_META_headset_id, 246) \ + _(XR_META_spatial_entity_discovery, 248) \ + _(XR_META_hand_tracking_microgestures, 253) \ + _(XR_META_recommended_layer_resolution, 255) \ + _(XR_META_spatial_entity_persistence, 260) \ + _(XR_META_passthrough_color_lut, 267) \ + _(XR_META_spatial_entity_mesh, 270) \ + _(XR_META_automatic_layer_filter, 272) \ + _(XR_META_body_tracking_full_body, 275) \ + _(XR_META_touch_controller_plus, 280) \ + _(XR_META_passthrough_layer_resumed_event, 283) \ + _(XR_META_body_tracking_calibration, 284) \ + _(XR_META_body_tracking_fidelity, 285) \ + _(XR_FB_face_tracking2, 288) \ + _(XR_META_spatial_entity_sharing, 291) \ + _(XR_META_environment_depth, 292) \ + _(XR_EXT_uuid, 300) \ + _(XR_EXT_render_model, 301) \ + _(XR_EXT_interaction_render_model, 302) \ + _(XR_EXT_hand_interaction, 303) \ + _(XR_QCOM_tracking_optimization_settings, 307) \ + _(XR_QCOM_hand_tracking_gesture, 311) \ + _(XR_HTC_passthrough, 318) \ + _(XR_HTC_foveation, 319) \ + _(XR_HTC_anchor, 320) \ + _(XR_HTC_body_tracking, 321) \ + _(XR_EXT_active_action_set_priority, 374) \ + _(XR_MNDX_force_feedback_curl, 376) \ + _(XR_BD_controller_interaction, 385) \ + _(XR_BD_body_tracking, 386) \ + _(XR_BD_facial_simulation, 387) \ + _(XR_BD_spatial_sensing, 390) \ + _(XR_BD_spatial_anchor, 391) \ + _(XR_BD_spatial_anchor_sharing, 392) \ + _(XR_BD_spatial_scene, 393) \ + _(XR_BD_spatial_mesh, 394) \ + _(XR_BD_future_progress, 395) \ + _(XR_BD_body_tracking_auxiliary_metrics, 396) \ + _(XR_BD_spatial_plane, 397) \ + _(XR_BD_spatial_light_estimation, 398) \ + _(XR_BD_ultra_controller_interaction, 404) \ + _(XR_BD_spatial_audio_rendering, 410) \ + _(XR_EXT_local_floor, 427) \ + _(XR_EXT_hand_tracking_data_source, 429) \ + _(XR_EXT_plane_detection, 430) \ + _(XR_OPPO_controller_interaction, 454) \ + _(XR_ANDROID_trackables, 456) \ + _(XR_ANDROID_eye_tracking, 457) \ + _(XR_ANDROID_device_anchor_persistence, 458) \ + _(XR_ANDROID_face_tracking, 459) \ + _(XR_ANDROID_passthrough_camera_state, 461) \ + _(XR_ANDROID_recommended_resolution, 462) \ + _(XR_ANDROID_composition_layer_passthrough_mesh, 463) \ + _(XR_ANDROID_raycast, 464) \ + _(XR_ANDROID_performance_metrics, 466) \ + _(XR_ANDROID_trackables_object, 467) \ + _(XR_ANDROID_unbounded_reference_space, 468) \ + _(XR_EXT_future, 470) \ + _(XR_EXT_user_presence, 471) \ + _(XR_KHR_locate_spaces, 472) \ + _(XR_ML_user_calibration, 473) \ + _(XR_ML_system_notifications, 474) \ + _(XR_ML_world_mesh_detection, 475) \ + _(XR_ML_facial_expression, 483) \ + _(XR_ML_view_configuration_depth_range_change, 484) \ + _(XR_YVR_controller_interaction, 498) \ + _(XR_META_boundary_visibility, 529) \ + _(XR_META_simultaneous_hands_and_controllers, 533) \ + _(XR_META_face_tracking_visemes, 542) \ + _(XR_META_spatial_entity_semantic_label, 553) \ + _(XR_META_spatial_entity_room_mesh, 554) \ + _(XR_EXT_composition_layer_inverted_alpha, 555) \ + _(XR_META_colocation_discovery, 572) \ + _(XR_META_spatial_entity_group_sharing, 573) \ + _(XR_META_environment_raycast, 593) \ + _(XR_META_tile_properties_hint, 610) \ + _(XR_META_hand_tracking_unextrapolated_poses, 694) \ + _(XR_META_hand_tracking_frequency_hint, 695) \ + _(XR_META_hand_tracking_wide_motion_mode2, 696) \ + _(XR_ANDROID_light_estimation, 701) \ + _(XR_ANDROID_anchor_sharing_export, 702) \ + _(XR_ANDROID_mouse_interaction, 705) \ + _(XR_ANDROID_trackables_marker, 708) \ + _(XR_ANDROID_trackables_qr_code, 709) \ + _(XR_ANDROID_trackables_image, 710) \ + _(XR_KHR_maintenance1, 711) \ + _(XR_KHR_generic_controller, 712) \ + _(XR_ANDROID_scene_meshing, 719) \ + _(XR_EXT_spatial_entity, 741) \ + _(XR_EXT_spatial_plane_tracking, 742) \ + _(XR_EXT_stationary_reference_space, 743) \ + _(XR_EXT_spatial_marker_tracking, 744) \ + _(XR_LOGITECH_mx_ink_stylus_interaction, 746) \ + _(XR_BD_dynamic_object_tracking, 747) \ + _(XR_BD_dynamic_object_keyboard, 748) \ + _(XR_BD_dynamic_object_mouse, 749) \ + _(XR_BD_camera_image, 756) \ + _(XR_ANDROID_spatial_discovery_bounds, 762) \ + _(XR_EXT_spatial_anchor, 763) \ + _(XR_EXT_spatial_persistence, 764) \ + _(XR_EXT_haptic_parametric, 776) \ + _(XR_SONY_swapchain_color_space, 777) \ + _(XR_SONY_hdr_metadata, 778) \ + _(XR_EXT_spatial_persistence_operations, 782) \ + _(XR_EXT_spatial_image_tracking, 783) \ + _(XR_ANDROID_spatial_object_tracking, 786) \ + _(XR_ANDROID_spatial_discovery_raycast, 787) \ + _(XR_ANDROID_google_cloud_auth, 788) \ + _(XR_ANDROID_geospatial, 790) \ + _(XR_ANDROID_spatial_entity_bound_anchor, 791) \ + _(XR_ANDROID_spatial_component_subsumed_by, 792) \ + _(XR_ANDROID_spatial_anchor_space, 796) \ + _(XR_ANDROID_geospatial_anchor, 798) \ + _(XR_EXT_spatial_container, 811) \ + _(XR_EXT_spatial_container_self_rendering, 814) \ + _(XR_EXT_interaction_profile_battery_state_display, 837) \ + _(XR_EXT_loader_init_properties, 839) \ + _(XR_EXT_view_configuration_views_change, 840) \ + _(XR_KHR_extended_result_name_lengths, 875) \ + + + +/// For every function defined by XR_VERSION_1_0 in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_VERSION_1_0(_) \ + _(GetInstanceProcAddr, VERSION_1_0) \ + _(EnumerateApiLayerProperties, VERSION_1_0) \ + _(EnumerateInstanceExtensionProperties, VERSION_1_0) \ + _(CreateInstance, VERSION_1_0) \ + _(DestroyInstance, VERSION_1_0) \ + _(GetInstanceProperties, VERSION_1_0) \ + _(PollEvent, VERSION_1_0) \ + _(ResultToString, VERSION_1_0) \ + _(StructureTypeToString, VERSION_1_0) \ + _(GetSystem, VERSION_1_0) \ + _(GetSystemProperties, VERSION_1_0) \ + _(EnumerateEnvironmentBlendModes, VERSION_1_0) \ + _(CreateSession, VERSION_1_0) \ + _(DestroySession, VERSION_1_0) \ + _(EnumerateReferenceSpaces, VERSION_1_0) \ + _(CreateReferenceSpace, VERSION_1_0) \ + _(GetReferenceSpaceBoundsRect, VERSION_1_0) \ + _(CreateActionSpace, VERSION_1_0) \ + _(LocateSpace, VERSION_1_0) \ + _(DestroySpace, VERSION_1_0) \ + _(EnumerateViewConfigurations, VERSION_1_0) \ + _(GetViewConfigurationProperties, VERSION_1_0) \ + _(EnumerateViewConfigurationViews, VERSION_1_0) \ + _(EnumerateSwapchainFormats, VERSION_1_0) \ + _(CreateSwapchain, VERSION_1_0) \ + _(DestroySwapchain, VERSION_1_0) \ + _(EnumerateSwapchainImages, VERSION_1_0) \ + _(AcquireSwapchainImage, VERSION_1_0) \ + _(WaitSwapchainImage, VERSION_1_0) \ + _(ReleaseSwapchainImage, VERSION_1_0) \ + _(BeginSession, VERSION_1_0) \ + _(EndSession, VERSION_1_0) \ + _(RequestExitSession, VERSION_1_0) \ + _(WaitFrame, VERSION_1_0) \ + _(BeginFrame, VERSION_1_0) \ + _(EndFrame, VERSION_1_0) \ + _(LocateViews, VERSION_1_0) \ + _(StringToPath, VERSION_1_0) \ + _(PathToString, VERSION_1_0) \ + _(CreateActionSet, VERSION_1_0) \ + _(DestroyActionSet, VERSION_1_0) \ + _(CreateAction, VERSION_1_0) \ + _(DestroyAction, VERSION_1_0) \ + _(SuggestInteractionProfileBindings, VERSION_1_0) \ + _(AttachSessionActionSets, VERSION_1_0) \ + _(GetCurrentInteractionProfile, VERSION_1_0) \ + _(GetActionStateBoolean, VERSION_1_0) \ + _(GetActionStateFloat, VERSION_1_0) \ + _(GetActionStateVector2f, VERSION_1_0) \ + _(GetActionStatePose, VERSION_1_0) \ + _(SyncActions, VERSION_1_0) \ + _(EnumerateBoundSourcesForAction, VERSION_1_0) \ + _(GetInputSourceLocalizedName, VERSION_1_0) \ + _(ApplyHapticFeedback, VERSION_1_0) \ + _(StopHapticFeedback, VERSION_1_0) \ + + +/// For every function defined by XR_LOADER_VERSION_1_0 in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_LOADER_VERSION_1_0(_) \ + _(CreateApiLayerInstance, LOADER_VERSION_1_0) \ + _(NegotiateLoaderRuntimeInterface, LOADER_VERSION_1_0) \ + _(NegotiateLoaderApiLayerInterface, LOADER_VERSION_1_0) \ + + +/// For every function defined by XR_VERSION_1_1 in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_VERSION_1_1(_) \ + _(LocateSpaces, VERSION_1_1) \ + + +/// For every function defined by XR_KHR_android_thread_settings in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_android_thread_settings(_) \ + _(SetAndroidApplicationThreadKHR, KHR_android_thread_settings) \ + + +/// For every function defined by XR_KHR_android_surface_swapchain in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_android_surface_swapchain(_) \ + _(CreateSwapchainAndroidSurfaceKHR, KHR_android_surface_swapchain) \ + + +/// For every function defined by XR_KHR_composition_layer_cube in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_composition_layer_cube(_) + + +/// For every function defined by XR_KHR_android_create_instance in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_android_create_instance(_) + + +/// For every function defined by XR_KHR_composition_layer_depth in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_composition_layer_depth(_) + + +/// For every function defined by XR_KHR_vulkan_swapchain_format_list in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_vulkan_swapchain_format_list(_) + + +/// For every function defined by XR_KHR_composition_layer_cylinder in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_composition_layer_cylinder(_) + + +/// For every function defined by XR_KHR_composition_layer_equirect in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_composition_layer_equirect(_) + + +/// For every function defined by XR_KHR_opengl_enable in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_opengl_enable(_) \ + _(GetOpenGLGraphicsRequirementsKHR, KHR_opengl_enable) \ + + +/// For every function defined by XR_KHR_opengl_es_enable in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_opengl_es_enable(_) \ + _(GetOpenGLESGraphicsRequirementsKHR, KHR_opengl_es_enable) \ + + +/// For every function defined by XR_KHR_vulkan_enable in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_vulkan_enable(_) \ + _(GetVulkanInstanceExtensionsKHR, KHR_vulkan_enable) \ + _(GetVulkanDeviceExtensionsKHR, KHR_vulkan_enable) \ + _(GetVulkanGraphicsDeviceKHR, KHR_vulkan_enable) \ + _(GetVulkanGraphicsRequirementsKHR, KHR_vulkan_enable) \ + + +/// For every function defined by XR_KHR_D3D11_enable in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_D3D11_enable(_) \ + _(GetD3D11GraphicsRequirementsKHR, KHR_D3D11_enable) \ + + +/// For every function defined by XR_KHR_D3D12_enable in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_D3D12_enable(_) \ + _(GetD3D12GraphicsRequirementsKHR, KHR_D3D12_enable) \ + + +/// For every function defined by XR_KHR_metal_enable in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_metal_enable(_) \ + _(GetMetalGraphicsRequirementsKHR, KHR_metal_enable) \ + + +/// For every function defined by XR_KHR_visibility_mask in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_visibility_mask(_) \ + _(GetVisibilityMaskKHR, KHR_visibility_mask) \ + + +/// For every function defined by XR_KHR_composition_layer_color_scale_bias in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_composition_layer_color_scale_bias(_) + + +/// For every function defined by XR_KHR_win32_convert_performance_counter_time in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_win32_convert_performance_counter_time(_) \ + _(ConvertWin32PerformanceCounterToTimeKHR, KHR_win32_convert_performance_counter_time) \ + _(ConvertTimeToWin32PerformanceCounterKHR, KHR_win32_convert_performance_counter_time) \ + + +/// For every function defined by XR_KHR_convert_timespec_time in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_convert_timespec_time(_) \ + _(ConvertTimespecTimeToTimeKHR, KHR_convert_timespec_time) \ + _(ConvertTimeToTimespecTimeKHR, KHR_convert_timespec_time) \ + + +/// For every function defined by XR_KHR_loader_init in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_loader_init(_) \ + _(InitializeLoaderKHR, KHR_loader_init) \ + + +/// For every function defined by XR_KHR_loader_init_android in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_loader_init_android(_) + + +/// For every function defined by XR_KHR_vulkan_enable2 in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_vulkan_enable2(_) \ + _(CreateVulkanInstanceKHR, KHR_vulkan_enable2) \ + _(CreateVulkanDeviceKHR, KHR_vulkan_enable2) \ + _(GetVulkanGraphicsDevice2KHR, KHR_vulkan_enable2) \ + _(GetVulkanGraphicsRequirements2KHR, KHR_vulkan_enable2) \ + + +/// For every function defined by XR_KHR_composition_layer_equirect2 in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_composition_layer_equirect2(_) + + +/// For every function defined by XR_KHR_binding_modification in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_binding_modification(_) + + +/// For every function defined by XR_KHR_extended_struct_name_lengths in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_extended_struct_name_lengths(_) \ + _(StructureTypeToString2KHR, KHR_extended_struct_name_lengths) \ + + +/// For every function defined by XR_KHR_swapchain_usage_input_attachment_bit in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_swapchain_usage_input_attachment_bit(_) + + +/// For every function defined by XR_KHR_locate_spaces in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_locate_spaces(_) \ + _(LocateSpacesKHR, KHR_locate_spaces) \ + + +/// For every function defined by XR_KHR_maintenance1 in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_maintenance1(_) + + +/// For every function defined by XR_KHR_generic_controller in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_generic_controller(_) + + +/// For every function defined by XR_KHR_extended_result_name_lengths in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_KHR_extended_result_name_lengths(_) \ + _(ResultToString2KHR, KHR_extended_result_name_lengths) \ + + +/// For every function defined by XR_EXT_performance_settings in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_performance_settings(_) \ + _(PerfSettingsSetPerformanceLevelEXT, EXT_performance_settings) \ + + +/// For every function defined by XR_EXT_thermal_query in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_thermal_query(_) \ + _(ThermalGetTemperatureTrendEXT, EXT_thermal_query) \ + + +/// For every function defined by XR_EXT_debug_utils in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_debug_utils(_) \ + _(SetDebugUtilsObjectNameEXT, EXT_debug_utils) \ + _(CreateDebugUtilsMessengerEXT, EXT_debug_utils) \ + _(DestroyDebugUtilsMessengerEXT, EXT_debug_utils) \ + _(SubmitDebugUtilsMessageEXT, EXT_debug_utils) \ + _(SessionBeginDebugUtilsLabelRegionEXT, EXT_debug_utils) \ + _(SessionEndDebugUtilsLabelRegionEXT, EXT_debug_utils) \ + _(SessionInsertDebugUtilsLabelEXT, EXT_debug_utils) \ + + +/// For every function defined by XR_EXT_eye_gaze_interaction in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_eye_gaze_interaction(_) + + +/// For every function defined by XR_EXTX_overlay in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXTX_overlay(_) + + +/// For every function defined by XR_VARJO_quad_views in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_VARJO_quad_views(_) + + +/// For every function defined by XR_MSFT_unbounded_reference_space in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_MSFT_unbounded_reference_space(_) + + +/// For every function defined by XR_MSFT_spatial_anchor in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_MSFT_spatial_anchor(_) \ + _(CreateSpatialAnchorMSFT, MSFT_spatial_anchor) \ + _(CreateSpatialAnchorSpaceMSFT, MSFT_spatial_anchor) \ + _(DestroySpatialAnchorMSFT, MSFT_spatial_anchor) \ + + +/// For every function defined by XR_FB_composition_layer_image_layout in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_composition_layer_image_layout(_) + + +/// For every function defined by XR_FB_composition_layer_alpha_blend in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_composition_layer_alpha_blend(_) + + +/// For every function defined by XR_MND_headless in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_MND_headless(_) + + +/// For every function defined by XR_OCULUS_android_session_state_enable in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_OCULUS_android_session_state_enable(_) + + +/// For every function defined by XR_EXT_view_configuration_depth_range in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_view_configuration_depth_range(_) + + +/// For every function defined by XR_EXT_conformance_automation in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_conformance_automation(_) \ + _(SetInputDeviceActiveEXT, EXT_conformance_automation) \ + _(SetInputDeviceStateBoolEXT, EXT_conformance_automation) \ + _(SetInputDeviceStateFloatEXT, EXT_conformance_automation) \ + _(SetInputDeviceStateVector2fEXT, EXT_conformance_automation) \ + _(SetInputDeviceLocationEXT, EXT_conformance_automation) \ + + +/// For every function defined by XR_MNDX_egl_enable in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_MNDX_egl_enable(_) + + +/// For every function defined by XR_MSFT_spatial_graph_bridge in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_MSFT_spatial_graph_bridge(_) \ + _(CreateSpatialGraphNodeSpaceMSFT, MSFT_spatial_graph_bridge) \ + _(TryCreateSpatialGraphStaticNodeBindingMSFT, MSFT_spatial_graph_bridge) \ + _(DestroySpatialGraphNodeBindingMSFT, MSFT_spatial_graph_bridge) \ + _(GetSpatialGraphNodeBindingPropertiesMSFT, MSFT_spatial_graph_bridge) \ + + +/// For every function defined by XR_MSFT_hand_interaction in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_MSFT_hand_interaction(_) + + +/// For every function defined by XR_EXT_hand_tracking in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_hand_tracking(_) \ + _(CreateHandTrackerEXT, EXT_hand_tracking) \ + _(DestroyHandTrackerEXT, EXT_hand_tracking) \ + _(LocateHandJointsEXT, EXT_hand_tracking) \ + + +/// For every function defined by XR_MSFT_hand_tracking_mesh in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_MSFT_hand_tracking_mesh(_) \ + _(CreateHandMeshSpaceMSFT, MSFT_hand_tracking_mesh) \ + _(UpdateHandMeshMSFT, MSFT_hand_tracking_mesh) \ + + +/// For every function defined by XR_MSFT_secondary_view_configuration in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_MSFT_secondary_view_configuration(_) + + +/// For every function defined by XR_MSFT_first_person_observer in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_MSFT_first_person_observer(_) + + +/// For every function defined by XR_MSFT_controller_model in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_MSFT_controller_model(_) \ + _(GetControllerModelKeyMSFT, MSFT_controller_model) \ + _(LoadControllerModelMSFT, MSFT_controller_model) \ + _(GetControllerModelPropertiesMSFT, MSFT_controller_model) \ + _(GetControllerModelStateMSFT, MSFT_controller_model) \ + + +/// For every function defined by XR_MSFT_perception_anchor_interop in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_MSFT_perception_anchor_interop(_) \ + _(CreateSpatialAnchorFromPerceptionAnchorMSFT, MSFT_perception_anchor_interop) \ + _(TryGetPerceptionAnchorFromSpatialAnchorMSFT, MSFT_perception_anchor_interop) \ + + +/// For every function defined by XR_EXT_win32_appcontainer_compatible in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_win32_appcontainer_compatible(_) + + +/// For every function defined by XR_EPIC_view_configuration_fov in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EPIC_view_configuration_fov(_) + + +/// For every function defined by XR_MSFT_holographic_window_attachment in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_MSFT_holographic_window_attachment(_) + + +/// For every function defined by XR_MSFT_composition_layer_reprojection in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_MSFT_composition_layer_reprojection(_) \ + _(EnumerateReprojectionModesMSFT, MSFT_composition_layer_reprojection) \ + + +/// For every function defined by XR_HUAWEI_controller_interaction in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_HUAWEI_controller_interaction(_) + + +/// For every function defined by XR_FB_android_surface_swapchain_create in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_android_surface_swapchain_create(_) + + +/// For every function defined by XR_FB_swapchain_update_state in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_swapchain_update_state(_) \ + _(UpdateSwapchainFB, FB_swapchain_update_state) \ + _(GetSwapchainStateFB, FB_swapchain_update_state) \ + + +/// For every function defined by XR_FB_composition_layer_secure_content in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_composition_layer_secure_content(_) + + +/// For every function defined by XR_FB_body_tracking in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_body_tracking(_) \ + _(CreateBodyTrackerFB, FB_body_tracking) \ + _(DestroyBodyTrackerFB, FB_body_tracking) \ + _(LocateBodyJointsFB, FB_body_tracking) \ + _(GetBodySkeletonFB, FB_body_tracking) \ + + +/// For every function defined by XR_EXT_dpad_binding in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_dpad_binding(_) + + +/// For every function defined by XR_VALVE_analog_threshold in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_VALVE_analog_threshold(_) + + +/// For every function defined by XR_EXT_hand_joints_motion_range in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_hand_joints_motion_range(_) + + +/// For every function defined by XR_EXT_samsung_odyssey_controller in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_samsung_odyssey_controller(_) + + +/// For every function defined by XR_EXT_hp_mixed_reality_controller in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_hp_mixed_reality_controller(_) + + +/// For every function defined by XR_MND_swapchain_usage_input_attachment_bit in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_MND_swapchain_usage_input_attachment_bit(_) + + +/// For every function defined by XR_MSFT_scene_understanding in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_MSFT_scene_understanding(_) \ + _(EnumerateSceneComputeFeaturesMSFT, MSFT_scene_understanding) \ + _(CreateSceneObserverMSFT, MSFT_scene_understanding) \ + _(DestroySceneObserverMSFT, MSFT_scene_understanding) \ + _(CreateSceneMSFT, MSFT_scene_understanding) \ + _(DestroySceneMSFT, MSFT_scene_understanding) \ + _(ComputeNewSceneMSFT, MSFT_scene_understanding) \ + _(GetSceneComputeStateMSFT, MSFT_scene_understanding) \ + _(GetSceneComponentsMSFT, MSFT_scene_understanding) \ + _(LocateSceneComponentsMSFT, MSFT_scene_understanding) \ + _(GetSceneMeshBuffersMSFT, MSFT_scene_understanding) \ + + +/// For every function defined by XR_MSFT_scene_understanding_serialization in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_MSFT_scene_understanding_serialization(_) \ + _(DeserializeSceneMSFT, MSFT_scene_understanding_serialization) \ + _(GetSerializedSceneFragmentDataMSFT, MSFT_scene_understanding_serialization) \ + + +/// For every function defined by XR_FB_display_refresh_rate in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_display_refresh_rate(_) \ + _(EnumerateDisplayRefreshRatesFB, FB_display_refresh_rate) \ + _(GetDisplayRefreshRateFB, FB_display_refresh_rate) \ + _(RequestDisplayRefreshRateFB, FB_display_refresh_rate) \ + + +/// For every function defined by XR_HTC_vive_cosmos_controller_interaction in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_HTC_vive_cosmos_controller_interaction(_) + + +/// For every function defined by XR_HTCX_vive_tracker_interaction in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_HTCX_vive_tracker_interaction(_) \ + _(EnumerateViveTrackerPathsHTCX, HTCX_vive_tracker_interaction) \ + + +/// For every function defined by XR_HTC_facial_tracking in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_HTC_facial_tracking(_) \ + _(CreateFacialTrackerHTC, HTC_facial_tracking) \ + _(DestroyFacialTrackerHTC, HTC_facial_tracking) \ + _(GetFacialExpressionsHTC, HTC_facial_tracking) \ + + +/// For every function defined by XR_HTC_vive_focus3_controller_interaction in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_HTC_vive_focus3_controller_interaction(_) + + +/// For every function defined by XR_HTC_hand_interaction in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_HTC_hand_interaction(_) + + +/// For every function defined by XR_HTC_vive_wrist_tracker_interaction in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_HTC_vive_wrist_tracker_interaction(_) + + +/// For every function defined by XR_FB_color_space in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_color_space(_) \ + _(EnumerateColorSpacesFB, FB_color_space) \ + _(SetColorSpaceFB, FB_color_space) \ + + +/// For every function defined by XR_FB_hand_tracking_mesh in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_hand_tracking_mesh(_) \ + _(GetHandMeshFB, FB_hand_tracking_mesh) \ + + +/// For every function defined by XR_FB_hand_tracking_aim in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_hand_tracking_aim(_) + + +/// For every function defined by XR_FB_hand_tracking_capsules in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_hand_tracking_capsules(_) + + +/// For every function defined by XR_FB_spatial_entity in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_spatial_entity(_) \ + _(CreateSpatialAnchorFB, FB_spatial_entity) \ + _(GetSpaceUuidFB, FB_spatial_entity) \ + _(EnumerateSpaceSupportedComponentsFB, FB_spatial_entity) \ + _(SetSpaceComponentStatusFB, FB_spatial_entity) \ + _(GetSpaceComponentStatusFB, FB_spatial_entity) \ + + +/// For every function defined by XR_FB_foveation in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_foveation(_) \ + _(CreateFoveationProfileFB, FB_foveation) \ + _(DestroyFoveationProfileFB, FB_foveation) \ + + +/// For every function defined by XR_FB_foveation_configuration in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_foveation_configuration(_) + + +/// For every function defined by XR_FB_keyboard_tracking in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_keyboard_tracking(_) \ + _(QuerySystemTrackedKeyboardFB, FB_keyboard_tracking) \ + _(CreateKeyboardSpaceFB, FB_keyboard_tracking) \ + + +/// For every function defined by XR_FB_triangle_mesh in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_triangle_mesh(_) \ + _(CreateTriangleMeshFB, FB_triangle_mesh) \ + _(DestroyTriangleMeshFB, FB_triangle_mesh) \ + _(TriangleMeshGetVertexBufferFB, FB_triangle_mesh) \ + _(TriangleMeshGetIndexBufferFB, FB_triangle_mesh) \ + _(TriangleMeshBeginUpdateFB, FB_triangle_mesh) \ + _(TriangleMeshEndUpdateFB, FB_triangle_mesh) \ + _(TriangleMeshBeginVertexBufferUpdateFB, FB_triangle_mesh) \ + _(TriangleMeshEndVertexBufferUpdateFB, FB_triangle_mesh) \ + + +/// For every function defined by XR_FB_passthrough in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_passthrough(_) \ + _(CreatePassthroughFB, FB_passthrough) \ + _(DestroyPassthroughFB, FB_passthrough) \ + _(PassthroughStartFB, FB_passthrough) \ + _(PassthroughPauseFB, FB_passthrough) \ + _(CreatePassthroughLayerFB, FB_passthrough) \ + _(DestroyPassthroughLayerFB, FB_passthrough) \ + _(PassthroughLayerPauseFB, FB_passthrough) \ + _(PassthroughLayerResumeFB, FB_passthrough) \ + _(PassthroughLayerSetStyleFB, FB_passthrough) \ + _(CreateGeometryInstanceFB, FB_passthrough) \ + _(DestroyGeometryInstanceFB, FB_passthrough) \ + _(GeometryInstanceSetTransformFB, FB_passthrough) \ + + +/// For every function defined by XR_FB_render_model in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_render_model(_) \ + _(EnumerateRenderModelPathsFB, FB_render_model) \ + _(GetRenderModelPropertiesFB, FB_render_model) \ + _(LoadRenderModelFB, FB_render_model) \ + + +/// For every function defined by XR_VARJO_foveated_rendering in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_VARJO_foveated_rendering(_) + + +/// For every function defined by XR_VARJO_composition_layer_depth_test in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_VARJO_composition_layer_depth_test(_) + + +/// For every function defined by XR_VARJO_environment_depth_estimation in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_VARJO_environment_depth_estimation(_) \ + _(SetEnvironmentDepthEstimationVARJO, VARJO_environment_depth_estimation) \ + + +/// For every function defined by XR_VARJO_marker_tracking in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_VARJO_marker_tracking(_) \ + _(SetMarkerTrackingVARJO, VARJO_marker_tracking) \ + _(SetMarkerTrackingTimeoutVARJO, VARJO_marker_tracking) \ + _(SetMarkerTrackingPredictionVARJO, VARJO_marker_tracking) \ + _(GetMarkerSizeVARJO, VARJO_marker_tracking) \ + _(CreateMarkerSpaceVARJO, VARJO_marker_tracking) \ + + +/// For every function defined by XR_VARJO_view_offset in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_VARJO_view_offset(_) \ + _(SetViewOffsetVARJO, VARJO_view_offset) \ + + +/// For every function defined by XR_VARJO_xr4_controller_interaction in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_VARJO_xr4_controller_interaction(_) + + +/// For every function defined by XR_ML_ml2_controller_interaction in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ML_ml2_controller_interaction(_) + + +/// For every function defined by XR_ML_frame_end_info in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ML_frame_end_info(_) + + +/// For every function defined by XR_ML_global_dimmer in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ML_global_dimmer(_) + + +/// For every function defined by XR_ML_compat in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ML_compat(_) \ + _(CreateSpaceFromCoordinateFrameUIDML, ML_compat) \ + + +/// For every function defined by XR_ML_marker_understanding in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ML_marker_understanding(_) \ + _(CreateMarkerDetectorML, ML_marker_understanding) \ + _(DestroyMarkerDetectorML, ML_marker_understanding) \ + _(SnapshotMarkerDetectorML, ML_marker_understanding) \ + _(GetMarkerDetectorStateML, ML_marker_understanding) \ + _(GetMarkersML, ML_marker_understanding) \ + _(GetMarkerReprojectionErrorML, ML_marker_understanding) \ + _(GetMarkerLengthML, ML_marker_understanding) \ + _(GetMarkerNumberML, ML_marker_understanding) \ + _(GetMarkerStringML, ML_marker_understanding) \ + _(CreateMarkerSpaceML, ML_marker_understanding) \ + + +/// For every function defined by XR_ML_localization_map in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ML_localization_map(_) \ + _(EnableLocalizationEventsML, ML_localization_map) \ + _(QueryLocalizationMapsML, ML_localization_map) \ + _(RequestMapLocalizationML, ML_localization_map) \ + _(ImportLocalizationMapML, ML_localization_map) \ + _(CreateExportedLocalizationMapML, ML_localization_map) \ + _(DestroyExportedLocalizationMapML, ML_localization_map) \ + _(GetExportedLocalizationMapDataML, ML_localization_map) \ + + +/// For every function defined by XR_ML_spatial_anchors in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ML_spatial_anchors(_) \ + _(CreateSpatialAnchorsAsyncML, ML_spatial_anchors) \ + _(CreateSpatialAnchorsCompleteML, ML_spatial_anchors) \ + _(GetSpatialAnchorStateML, ML_spatial_anchors) \ + + +/// For every function defined by XR_ML_spatial_anchors_storage in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ML_spatial_anchors_storage(_) \ + _(CreateSpatialAnchorsStorageML, ML_spatial_anchors_storage) \ + _(DestroySpatialAnchorsStorageML, ML_spatial_anchors_storage) \ + _(QuerySpatialAnchorsAsyncML, ML_spatial_anchors_storage) \ + _(QuerySpatialAnchorsCompleteML, ML_spatial_anchors_storage) \ + _(PublishSpatialAnchorsAsyncML, ML_spatial_anchors_storage) \ + _(PublishSpatialAnchorsCompleteML, ML_spatial_anchors_storage) \ + _(DeleteSpatialAnchorsAsyncML, ML_spatial_anchors_storage) \ + _(DeleteSpatialAnchorsCompleteML, ML_spatial_anchors_storage) \ + _(UpdateSpatialAnchorsExpirationAsyncML, ML_spatial_anchors_storage) \ + _(UpdateSpatialAnchorsExpirationCompleteML, ML_spatial_anchors_storage) \ + + +/// For every function defined by XR_MSFT_spatial_anchor_persistence in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_MSFT_spatial_anchor_persistence(_) \ + _(CreateSpatialAnchorStoreConnectionMSFT, MSFT_spatial_anchor_persistence) \ + _(DestroySpatialAnchorStoreConnectionMSFT, MSFT_spatial_anchor_persistence) \ + _(PersistSpatialAnchorMSFT, MSFT_spatial_anchor_persistence) \ + _(EnumeratePersistedSpatialAnchorNamesMSFT, MSFT_spatial_anchor_persistence) \ + _(CreateSpatialAnchorFromPersistedNameMSFT, MSFT_spatial_anchor_persistence) \ + _(UnpersistSpatialAnchorMSFT, MSFT_spatial_anchor_persistence) \ + _(ClearSpatialAnchorStoreMSFT, MSFT_spatial_anchor_persistence) \ + + +/// For every function defined by XR_MSFT_scene_marker in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_MSFT_scene_marker(_) \ + _(GetSceneMarkerRawDataMSFT, MSFT_scene_marker) \ + _(GetSceneMarkerDecodedStringMSFT, MSFT_scene_marker) \ + + +/// For every function defined by XR_ULTRALEAP_hand_tracking_forearm in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ULTRALEAP_hand_tracking_forearm(_) + + +/// For every function defined by XR_FB_spatial_entity_query in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_spatial_entity_query(_) \ + _(QuerySpacesFB, FB_spatial_entity_query) \ + _(RetrieveSpaceQueryResultsFB, FB_spatial_entity_query) \ + + +/// For every function defined by XR_FB_spatial_entity_storage in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_spatial_entity_storage(_) \ + _(SaveSpaceFB, FB_spatial_entity_storage) \ + _(EraseSpaceFB, FB_spatial_entity_storage) \ + + +/// For every function defined by XR_OCULUS_audio_device_guid in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_OCULUS_audio_device_guid(_) \ + _(GetAudioOutputDeviceGuidOculus, OCULUS_audio_device_guid) \ + _(GetAudioInputDeviceGuidOculus, OCULUS_audio_device_guid) \ + + +/// For every function defined by XR_FB_foveation_vulkan in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_foveation_vulkan(_) + + +/// For every function defined by XR_FB_swapchain_update_state_android_surface in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_swapchain_update_state_android_surface(_) + + +/// For every function defined by XR_FB_swapchain_update_state_opengl_es in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_swapchain_update_state_opengl_es(_) + + +/// For every function defined by XR_FB_swapchain_update_state_vulkan in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_swapchain_update_state_vulkan(_) + + +/// For every function defined by XR_FB_touch_controller_pro in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_touch_controller_pro(_) + + +/// For every function defined by XR_FB_spatial_entity_sharing in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_spatial_entity_sharing(_) \ + _(ShareSpacesFB, FB_spatial_entity_sharing) \ + + +/// For every function defined by XR_FB_space_warp in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_space_warp(_) + + +/// For every function defined by XR_FB_haptic_amplitude_envelope in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_haptic_amplitude_envelope(_) + + +/// For every function defined by XR_FB_scene in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_scene(_) \ + _(GetSpaceBoundingBox2DFB, FB_scene) \ + _(GetSpaceBoundingBox3DFB, FB_scene) \ + _(GetSpaceSemanticLabelsFB, FB_scene) \ + _(GetSpaceBoundary2DFB, FB_scene) \ + _(GetSpaceRoomLayoutFB, FB_scene) \ + + +/// For every function defined by XR_EXT_palm_pose in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_palm_pose(_) + + +/// For every function defined by XR_ALMALENCE_digital_lens_control in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ALMALENCE_digital_lens_control(_) \ + _(SetDigitalLensControlALMALENCE, ALMALENCE_digital_lens_control) \ + + +/// For every function defined by XR_FB_scene_capture in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_scene_capture(_) \ + _(RequestSceneCaptureFB, FB_scene_capture) \ + + +/// For every function defined by XR_FB_spatial_entity_container in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_spatial_entity_container(_) \ + _(GetSpaceContainerFB, FB_spatial_entity_container) \ + + +/// For every function defined by XR_META_foveation_eye_tracked in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_foveation_eye_tracked(_) \ + _(GetFoveationEyeTrackedStateMETA, META_foveation_eye_tracked) \ + + +/// For every function defined by XR_FB_face_tracking in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_face_tracking(_) \ + _(CreateFaceTrackerFB, FB_face_tracking) \ + _(DestroyFaceTrackerFB, FB_face_tracking) \ + _(GetFaceExpressionWeightsFB, FB_face_tracking) \ + + +/// For every function defined by XR_FB_eye_tracking_social in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_eye_tracking_social(_) \ + _(CreateEyeTrackerFB, FB_eye_tracking_social) \ + _(DestroyEyeTrackerFB, FB_eye_tracking_social) \ + _(GetEyeGazesFB, FB_eye_tracking_social) \ + + +/// For every function defined by XR_FB_passthrough_keyboard_hands in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_passthrough_keyboard_hands(_) \ + _(PassthroughLayerSetKeyboardHandsIntensityFB, FB_passthrough_keyboard_hands) \ + + +/// For every function defined by XR_FB_composition_layer_settings in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_composition_layer_settings(_) + + +/// For every function defined by XR_FB_touch_controller_proximity in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_touch_controller_proximity(_) + + +/// For every function defined by XR_FB_haptic_pcm in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_haptic_pcm(_) \ + _(GetDeviceSampleRateFB, FB_haptic_pcm) \ + + +/// For every function defined by XR_EXT_frame_synthesis in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_frame_synthesis(_) + + +/// For every function defined by XR_FB_composition_layer_depth_test in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_composition_layer_depth_test(_) + + +/// For every function defined by XR_META_local_dimming in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_local_dimming(_) + + +/// For every function defined by XR_META_passthrough_preferences in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_passthrough_preferences(_) \ + _(GetPassthroughPreferencesMETA, META_passthrough_preferences) \ + + +/// For every function defined by XR_META_virtual_keyboard in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_virtual_keyboard(_) \ + _(CreateVirtualKeyboardMETA, META_virtual_keyboard) \ + _(DestroyVirtualKeyboardMETA, META_virtual_keyboard) \ + _(CreateVirtualKeyboardSpaceMETA, META_virtual_keyboard) \ + _(SuggestVirtualKeyboardLocationMETA, META_virtual_keyboard) \ + _(GetVirtualKeyboardScaleMETA, META_virtual_keyboard) \ + _(SetVirtualKeyboardModelVisibilityMETA, META_virtual_keyboard) \ + _(GetVirtualKeyboardModelAnimationStatesMETA, META_virtual_keyboard) \ + _(GetVirtualKeyboardDirtyTexturesMETA, META_virtual_keyboard) \ + _(GetVirtualKeyboardTextureDataMETA, META_virtual_keyboard) \ + _(SendVirtualKeyboardInputMETA, META_virtual_keyboard) \ + _(ChangeVirtualKeyboardTextContextMETA, META_virtual_keyboard) \ + + +/// For every function defined by XR_OCULUS_external_camera in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_OCULUS_external_camera(_) \ + _(EnumerateExternalCamerasOCULUS, OCULUS_external_camera) \ + + +/// For every function defined by XR_META_vulkan_swapchain_create_info in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_vulkan_swapchain_create_info(_) + + +/// For every function defined by XR_META_performance_metrics in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_performance_metrics(_) \ + _(EnumeratePerformanceMetricsCounterPathsMETA, META_performance_metrics) \ + _(SetPerformanceMetricsStateMETA, META_performance_metrics) \ + _(GetPerformanceMetricsStateMETA, META_performance_metrics) \ + _(QueryPerformanceMetricsCounterMETA, META_performance_metrics) \ + + +/// For every function defined by XR_FB_spatial_entity_storage_batch in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_spatial_entity_storage_batch(_) \ + _(SaveSpaceListFB, FB_spatial_entity_storage_batch) \ + + +/// For every function defined by XR_META_detached_controllers in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_detached_controllers(_) + + +/// For every function defined by XR_FB_spatial_entity_user in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_spatial_entity_user(_) \ + _(CreateSpaceUserFB, FB_spatial_entity_user) \ + _(GetSpaceUserIdFB, FB_spatial_entity_user) \ + _(DestroySpaceUserFB, FB_spatial_entity_user) \ + + +/// For every function defined by XR_META_headset_id in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_headset_id(_) + + +/// For every function defined by XR_META_spatial_entity_discovery in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_spatial_entity_discovery(_) \ + _(DiscoverSpacesMETA, META_spatial_entity_discovery) \ + _(RetrieveSpaceDiscoveryResultsMETA, META_spatial_entity_discovery) \ + + +/// For every function defined by XR_META_hand_tracking_microgestures in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_hand_tracking_microgestures(_) + + +/// For every function defined by XR_META_recommended_layer_resolution in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_recommended_layer_resolution(_) \ + _(GetRecommendedLayerResolutionMETA, META_recommended_layer_resolution) \ + + +/// For every function defined by XR_META_spatial_entity_persistence in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_spatial_entity_persistence(_) \ + _(SaveSpacesMETA, META_spatial_entity_persistence) \ + _(EraseSpacesMETA, META_spatial_entity_persistence) \ + + +/// For every function defined by XR_META_passthrough_color_lut in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_passthrough_color_lut(_) \ + _(CreatePassthroughColorLutMETA, META_passthrough_color_lut) \ + _(DestroyPassthroughColorLutMETA, META_passthrough_color_lut) \ + _(UpdatePassthroughColorLutMETA, META_passthrough_color_lut) \ + + +/// For every function defined by XR_META_spatial_entity_mesh in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_spatial_entity_mesh(_) \ + _(GetSpaceTriangleMeshMETA, META_spatial_entity_mesh) \ + + +/// For every function defined by XR_META_automatic_layer_filter in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_automatic_layer_filter(_) + + +/// For every function defined by XR_META_body_tracking_full_body in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_body_tracking_full_body(_) + + +/// For every function defined by XR_META_touch_controller_plus in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_touch_controller_plus(_) + + +/// For every function defined by XR_META_passthrough_layer_resumed_event in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_passthrough_layer_resumed_event(_) + + +/// For every function defined by XR_META_body_tracking_calibration in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_body_tracking_calibration(_) \ + _(SuggestBodyTrackingCalibrationOverrideMETA, META_body_tracking_calibration) \ + _(ResetBodyTrackingCalibrationMETA, META_body_tracking_calibration) \ + + +/// For every function defined by XR_META_body_tracking_fidelity in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_body_tracking_fidelity(_) \ + _(RequestBodyTrackingFidelityMETA, META_body_tracking_fidelity) \ + + +/// For every function defined by XR_FB_face_tracking2 in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_FB_face_tracking2(_) \ + _(CreateFaceTracker2FB, FB_face_tracking2) \ + _(DestroyFaceTracker2FB, FB_face_tracking2) \ + _(GetFaceExpressionWeights2FB, FB_face_tracking2) \ + + +/// For every function defined by XR_META_spatial_entity_sharing in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_spatial_entity_sharing(_) \ + _(ShareSpacesMETA, META_spatial_entity_sharing) \ + + +/// For every function defined by XR_META_environment_depth in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_environment_depth(_) \ + _(CreateEnvironmentDepthProviderMETA, META_environment_depth) \ + _(DestroyEnvironmentDepthProviderMETA, META_environment_depth) \ + _(StartEnvironmentDepthProviderMETA, META_environment_depth) \ + _(StopEnvironmentDepthProviderMETA, META_environment_depth) \ + _(CreateEnvironmentDepthSwapchainMETA, META_environment_depth) \ + _(DestroyEnvironmentDepthSwapchainMETA, META_environment_depth) \ + _(EnumerateEnvironmentDepthSwapchainImagesMETA, META_environment_depth) \ + _(GetEnvironmentDepthSwapchainStateMETA, META_environment_depth) \ + _(AcquireEnvironmentDepthImageMETA, META_environment_depth) \ + _(SetEnvironmentDepthHandRemovalMETA, META_environment_depth) \ + + +/// For every function defined by XR_EXT_uuid in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_uuid(_) + + +/// For every function defined by XR_EXT_render_model in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_render_model(_) \ + _(CreateRenderModelEXT, EXT_render_model) \ + _(DestroyRenderModelEXT, EXT_render_model) \ + _(GetRenderModelPropertiesEXT, EXT_render_model) \ + _(CreateRenderModelSpaceEXT, EXT_render_model) \ + _(CreateRenderModelAssetEXT, EXT_render_model) \ + _(DestroyRenderModelAssetEXT, EXT_render_model) \ + _(GetRenderModelAssetDataEXT, EXT_render_model) \ + _(GetRenderModelAssetPropertiesEXT, EXT_render_model) \ + _(GetRenderModelStateEXT, EXT_render_model) \ + + +/// For every function defined by XR_EXT_interaction_render_model in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_interaction_render_model(_) \ + _(EnumerateInteractionRenderModelIdsEXT, EXT_interaction_render_model) \ + _(EnumerateRenderModelSubactionPathsEXT, EXT_interaction_render_model) \ + _(GetRenderModelPoseTopLevelUserPathEXT, EXT_interaction_render_model) \ + + +/// For every function defined by XR_EXT_hand_interaction in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_hand_interaction(_) + + +/// For every function defined by XR_QCOM_tracking_optimization_settings in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_QCOM_tracking_optimization_settings(_) \ + _(SetTrackingOptimizationSettingsHintQCOM, QCOM_tracking_optimization_settings) \ + + +/// For every function defined by XR_QCOM_hand_tracking_gesture in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_QCOM_hand_tracking_gesture(_) \ + _(GetHandGestureQCOM, QCOM_hand_tracking_gesture) \ + + +/// For every function defined by XR_HTC_passthrough in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_HTC_passthrough(_) \ + _(CreatePassthroughHTC, HTC_passthrough) \ + _(DestroyPassthroughHTC, HTC_passthrough) \ + + +/// For every function defined by XR_HTC_foveation in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_HTC_foveation(_) \ + _(ApplyFoveationHTC, HTC_foveation) \ + + +/// For every function defined by XR_HTC_anchor in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_HTC_anchor(_) \ + _(CreateSpatialAnchorHTC, HTC_anchor) \ + _(GetSpatialAnchorNameHTC, HTC_anchor) \ + + +/// For every function defined by XR_HTC_body_tracking in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_HTC_body_tracking(_) \ + _(CreateBodyTrackerHTC, HTC_body_tracking) \ + _(DestroyBodyTrackerHTC, HTC_body_tracking) \ + _(LocateBodyJointsHTC, HTC_body_tracking) \ + _(GetBodySkeletonHTC, HTC_body_tracking) \ + + +/// For every function defined by XR_EXT_active_action_set_priority in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_active_action_set_priority(_) + + +/// For every function defined by XR_MNDX_force_feedback_curl in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_MNDX_force_feedback_curl(_) \ + _(ApplyForceFeedbackCurlMNDX, MNDX_force_feedback_curl) \ + + +/// For every function defined by XR_BD_controller_interaction in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_BD_controller_interaction(_) + + +/// For every function defined by XR_BD_body_tracking in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_BD_body_tracking(_) \ + _(CreateBodyTrackerBD, BD_body_tracking) \ + _(DestroyBodyTrackerBD, BD_body_tracking) \ + _(LocateBodyJointsBD, BD_body_tracking) \ + + +/// For every function defined by XR_BD_facial_simulation in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_BD_facial_simulation(_) \ + _(EnumerateFacialSimulationModesBD, BD_facial_simulation) \ + _(CreateFaceTrackerBD, BD_facial_simulation) \ + _(DestroyFaceTrackerBD, BD_facial_simulation) \ + _(GetFacialSimulationDataBD, BD_facial_simulation) \ + _(SetFacialSimulationModeBD, BD_facial_simulation) \ + _(GetFacialSimulationModeBD, BD_facial_simulation) \ + + +/// For every function defined by XR_BD_spatial_sensing in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_BD_spatial_sensing(_) \ + _(EnumerateSpatialEntityComponentTypesBD, BD_spatial_sensing) \ + _(GetSpatialEntityUuidBD, BD_spatial_sensing) \ + _(GetSpatialEntityComponentDataBD, BD_spatial_sensing) \ + _(CreateSenseDataProviderBD, BD_spatial_sensing) \ + _(StartSenseDataProviderAsyncBD, BD_spatial_sensing) \ + _(StartSenseDataProviderCompleteBD, BD_spatial_sensing) \ + _(GetSenseDataProviderStateBD, BD_spatial_sensing) \ + _(QuerySenseDataAsyncBD, BD_spatial_sensing) \ + _(QuerySenseDataCompleteBD, BD_spatial_sensing) \ + _(DestroySenseDataSnapshotBD, BD_spatial_sensing) \ + _(GetQueriedSenseDataBD, BD_spatial_sensing) \ + _(StopSenseDataProviderBD, BD_spatial_sensing) \ + _(DestroySenseDataProviderBD, BD_spatial_sensing) \ + _(CreateSpatialEntityAnchorBD, BD_spatial_sensing) \ + _(DestroyAnchorBD, BD_spatial_sensing) \ + _(GetAnchorUuidBD, BD_spatial_sensing) \ + _(CreateAnchorSpaceBD, BD_spatial_sensing) \ + + +/// For every function defined by XR_BD_spatial_anchor in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_BD_spatial_anchor(_) \ + _(CreateSpatialAnchorAsyncBD, BD_spatial_anchor) \ + _(CreateSpatialAnchorCompleteBD, BD_spatial_anchor) \ + _(PersistSpatialAnchorAsyncBD, BD_spatial_anchor) \ + _(PersistSpatialAnchorCompleteBD, BD_spatial_anchor) \ + _(UnpersistSpatialAnchorAsyncBD, BD_spatial_anchor) \ + _(UnpersistSpatialAnchorCompleteBD, BD_spatial_anchor) \ + + +/// For every function defined by XR_BD_spatial_anchor_sharing in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_BD_spatial_anchor_sharing(_) \ + _(ShareSpatialAnchorAsyncBD, BD_spatial_anchor_sharing) \ + _(ShareSpatialAnchorCompleteBD, BD_spatial_anchor_sharing) \ + _(DownloadSharedSpatialAnchorAsyncBD, BD_spatial_anchor_sharing) \ + _(DownloadSharedSpatialAnchorCompleteBD, BD_spatial_anchor_sharing) \ + + +/// For every function defined by XR_BD_spatial_scene in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_BD_spatial_scene(_) \ + _(CaptureSceneAsyncBD, BD_spatial_scene) \ + _(CaptureSceneCompleteBD, BD_spatial_scene) \ + + +/// For every function defined by XR_BD_spatial_mesh in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_BD_spatial_mesh(_) + + +/// For every function defined by XR_BD_future_progress in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_BD_future_progress(_) + + +/// For every function defined by XR_BD_body_tracking_auxiliary_metrics in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_BD_body_tracking_auxiliary_metrics(_) \ + _(StartBodyTrackingCalibrationAppBD, BD_body_tracking_auxiliary_metrics) \ + _(GetBodyTrackingStateBD, BD_body_tracking_auxiliary_metrics) \ + + +/// For every function defined by XR_BD_spatial_plane in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_BD_spatial_plane(_) + + +/// For every function defined by XR_BD_spatial_light_estimation in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_BD_spatial_light_estimation(_) \ + _(EnumerateEnvironmentTextureResolutionsBD, BD_spatial_light_estimation) \ + _(EnumerateEnvironmentTexturePixelFormatsBD, BD_spatial_light_estimation) \ + _(EnumerateEnvironmentTextureTransferTypesBD, BD_spatial_light_estimation) \ + + +/// For every function defined by XR_BD_ultra_controller_interaction in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_BD_ultra_controller_interaction(_) + + +/// For every function defined by XR_BD_spatial_audio_rendering in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_BD_spatial_audio_rendering(_) \ + _(EnumerateSupportedAudioSampleRateBD, BD_spatial_audio_rendering) \ + _(QueryFramesPerBufferRangeBD, BD_spatial_audio_rendering) \ + _(CreateSpatialAudioRendererBD, BD_spatial_audio_rendering) \ + _(DestroySpatialAudioRendererBD, BD_spatial_audio_rendering) \ + _(CreateSoundObstacleMaterialBD, BD_spatial_audio_rendering) \ + _(UpdateSoundObstacleMaterialConfigBD, BD_spatial_audio_rendering) \ + _(DestroySoundObstacleMaterialBD, BD_spatial_audio_rendering) \ + _(CreateSoundObstacleBD, BD_spatial_audio_rendering) \ + _(UpdateSoundObstacleConfigBD, BD_spatial_audio_rendering) \ + _(DestroySoundObstacleBD, BD_spatial_audio_rendering) \ + _(CreateSoundObjectBD, BD_spatial_audio_rendering) \ + _(UpdateSoundObjectConfigBD, BD_spatial_audio_rendering) \ + _(SubmitSoundObjectBufferBD, BD_spatial_audio_rendering) \ + _(DestroySoundObjectBD, BD_spatial_audio_rendering) \ + _(CreateSoundFieldBD, BD_spatial_audio_rendering) \ + _(UpdateSoundFieldConfigBD, BD_spatial_audio_rendering) \ + _(SubmitSoundFieldBufferBD, BD_spatial_audio_rendering) \ + _(DestroySoundFieldBD, BD_spatial_audio_rendering) \ + _(WaitAudioPeriodBD, BD_spatial_audio_rendering) \ + _(EndAudioPeriodBD, BD_spatial_audio_rendering) \ + + +/// For every function defined by XR_EXT_local_floor in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_local_floor(_) + + +/// For every function defined by XR_EXT_hand_tracking_data_source in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_hand_tracking_data_source(_) + + +/// For every function defined by XR_EXT_plane_detection in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_plane_detection(_) \ + _(CreatePlaneDetectorEXT, EXT_plane_detection) \ + _(DestroyPlaneDetectorEXT, EXT_plane_detection) \ + _(BeginPlaneDetectionEXT, EXT_plane_detection) \ + _(GetPlaneDetectionStateEXT, EXT_plane_detection) \ + _(GetPlaneDetectionsEXT, EXT_plane_detection) \ + _(GetPlanePolygonBufferEXT, EXT_plane_detection) \ + + +/// For every function defined by XR_OPPO_controller_interaction in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_OPPO_controller_interaction(_) + + +/// For every function defined by XR_ANDROID_trackables in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_trackables(_) \ + _(EnumerateSupportedTrackableTypesANDROID, ANDROID_trackables) \ + _(EnumerateSupportedAnchorTrackableTypesANDROID, ANDROID_trackables) \ + _(CreateTrackableTrackerANDROID, ANDROID_trackables) \ + _(DestroyTrackableTrackerANDROID, ANDROID_trackables) \ + _(GetAllTrackablesANDROID, ANDROID_trackables) \ + _(GetTrackablePlaneANDROID, ANDROID_trackables) \ + _(CreateAnchorSpaceANDROID, ANDROID_trackables) \ + + +/// For every function defined by XR_ANDROID_eye_tracking in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_eye_tracking(_) \ + _(CreateEyeTrackerANDROID, ANDROID_eye_tracking) \ + _(DestroyEyeTrackerANDROID, ANDROID_eye_tracking) \ + _(GetFineTrackingEyesInfoANDROID, ANDROID_eye_tracking) \ + _(GetCoarseTrackingEyesInfoANDROID, ANDROID_eye_tracking) \ + + +/// For every function defined by XR_ANDROID_device_anchor_persistence in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_device_anchor_persistence(_) \ + _(EnumerateSupportedPersistenceAnchorTypesANDROID, ANDROID_device_anchor_persistence) \ + _(CreateDeviceAnchorPersistenceANDROID, ANDROID_device_anchor_persistence) \ + _(DestroyDeviceAnchorPersistenceANDROID, ANDROID_device_anchor_persistence) \ + _(PersistAnchorANDROID, ANDROID_device_anchor_persistence) \ + _(GetAnchorPersistStateANDROID, ANDROID_device_anchor_persistence) \ + _(CreatePersistedAnchorSpaceANDROID, ANDROID_device_anchor_persistence) \ + _(EnumeratePersistedAnchorsANDROID, ANDROID_device_anchor_persistence) \ + _(UnpersistAnchorANDROID, ANDROID_device_anchor_persistence) \ + + +/// For every function defined by XR_ANDROID_face_tracking in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_face_tracking(_) \ + _(CreateFaceTrackerANDROID, ANDROID_face_tracking) \ + _(DestroyFaceTrackerANDROID, ANDROID_face_tracking) \ + _(GetFaceStateANDROID, ANDROID_face_tracking) \ + _(GetFaceCalibrationStateANDROID, ANDROID_face_tracking) \ + + +/// For every function defined by XR_ANDROID_passthrough_camera_state in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_passthrough_camera_state(_) \ + _(GetPassthroughCameraStateANDROID, ANDROID_passthrough_camera_state) \ + + +/// For every function defined by XR_ANDROID_recommended_resolution in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_recommended_resolution(_) + + +/// For every function defined by XR_ANDROID_composition_layer_passthrough_mesh in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_composition_layer_passthrough_mesh(_) \ + _(CreatePassthroughLayerANDROID, ANDROID_composition_layer_passthrough_mesh) \ + _(DestroyPassthroughLayerANDROID, ANDROID_composition_layer_passthrough_mesh) \ + _(SetPassthroughLayerMeshANDROID, ANDROID_composition_layer_passthrough_mesh) \ + + +/// For every function defined by XR_ANDROID_raycast in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_raycast(_) \ + _(EnumerateRaycastSupportedTrackableTypesANDROID, ANDROID_raycast) \ + _(RaycastANDROID, ANDROID_raycast) \ + + +/// For every function defined by XR_ANDROID_performance_metrics in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_performance_metrics(_) \ + _(EnumeratePerformanceMetricsCounterPathsANDROID, ANDROID_performance_metrics) \ + _(SetPerformanceMetricsStateANDROID, ANDROID_performance_metrics) \ + _(GetPerformanceMetricsStateANDROID, ANDROID_performance_metrics) \ + _(QueryPerformanceMetricsCounterANDROID, ANDROID_performance_metrics) \ + + +/// For every function defined by XR_ANDROID_trackables_object in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_trackables_object(_) \ + _(GetTrackableObjectANDROID, ANDROID_trackables_object) \ + + +/// For every function defined by XR_ANDROID_unbounded_reference_space in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_unbounded_reference_space(_) + + +/// For every function defined by XR_EXT_future in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_future(_) \ + _(PollFutureEXT, EXT_future) \ + _(CancelFutureEXT, EXT_future) \ + + +/// For every function defined by XR_EXT_user_presence in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_user_presence(_) + + +/// For every function defined by XR_ML_user_calibration in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ML_user_calibration(_) \ + _(EnableUserCalibrationEventsML, ML_user_calibration) \ + + +/// For every function defined by XR_ML_system_notifications in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ML_system_notifications(_) \ + _(SetSystemNotificationsML, ML_system_notifications) \ + + +/// For every function defined by XR_ML_world_mesh_detection in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ML_world_mesh_detection(_) \ + _(CreateWorldMeshDetectorML, ML_world_mesh_detection) \ + _(DestroyWorldMeshDetectorML, ML_world_mesh_detection) \ + _(RequestWorldMeshStateAsyncML, ML_world_mesh_detection) \ + _(RequestWorldMeshStateCompleteML, ML_world_mesh_detection) \ + _(GetWorldMeshBufferRecommendSizeML, ML_world_mesh_detection) \ + _(AllocateWorldMeshBufferML, ML_world_mesh_detection) \ + _(FreeWorldMeshBufferML, ML_world_mesh_detection) \ + _(RequestWorldMeshAsyncML, ML_world_mesh_detection) \ + _(RequestWorldMeshCompleteML, ML_world_mesh_detection) \ + + +/// For every function defined by XR_ML_facial_expression in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ML_facial_expression(_) \ + _(CreateFacialExpressionClientML, ML_facial_expression) \ + _(DestroyFacialExpressionClientML, ML_facial_expression) \ + _(GetFacialExpressionBlendShapePropertiesML, ML_facial_expression) \ + + +/// For every function defined by XR_ML_view_configuration_depth_range_change in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ML_view_configuration_depth_range_change(_) + + +/// For every function defined by XR_YVR_controller_interaction in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_YVR_controller_interaction(_) + + +/// For every function defined by XR_META_boundary_visibility in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_boundary_visibility(_) \ + _(RequestBoundaryVisibilityMETA, META_boundary_visibility) \ + + +/// For every function defined by XR_META_simultaneous_hands_and_controllers in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_simultaneous_hands_and_controllers(_) \ + _(ResumeSimultaneousHandsAndControllersTrackingMETA, META_simultaneous_hands_and_controllers) \ + _(PauseSimultaneousHandsAndControllersTrackingMETA, META_simultaneous_hands_and_controllers) \ + + +/// For every function defined by XR_META_face_tracking_visemes in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_face_tracking_visemes(_) + + +/// For every function defined by XR_META_spatial_entity_semantic_label in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_spatial_entity_semantic_label(_) + + +/// For every function defined by XR_META_spatial_entity_room_mesh in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_spatial_entity_room_mesh(_) \ + _(GetSpaceRoomMeshMETA, META_spatial_entity_room_mesh) \ + _(GetSpaceRoomMeshFaceIndicesMETA, META_spatial_entity_room_mesh) \ + + +/// For every function defined by XR_EXT_composition_layer_inverted_alpha in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_composition_layer_inverted_alpha(_) + + +/// For every function defined by XR_META_colocation_discovery in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_colocation_discovery(_) \ + _(StartColocationDiscoveryMETA, META_colocation_discovery) \ + _(StopColocationDiscoveryMETA, META_colocation_discovery) \ + _(StartColocationAdvertisementMETA, META_colocation_discovery) \ + _(StopColocationAdvertisementMETA, META_colocation_discovery) \ + + +/// For every function defined by XR_META_spatial_entity_group_sharing in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_spatial_entity_group_sharing(_) + + +/// For every function defined by XR_META_environment_raycast in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_environment_raycast(_) \ + _(CreateEnvironmentRaycasterAsyncMETA, META_environment_raycast) \ + _(CreateEnvironmentRaycasterCompleteMETA, META_environment_raycast) \ + _(DestroyEnvironmentRaycasterMETA, META_environment_raycast) \ + _(PerformEnvironmentRaycastMETA, META_environment_raycast) \ + + +/// For every function defined by XR_META_tile_properties_hint in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_tile_properties_hint(_) \ + _(SetTilePropertiesHintMETA, META_tile_properties_hint) \ + + +/// For every function defined by XR_META_hand_tracking_unextrapolated_poses in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_hand_tracking_unextrapolated_poses(_) + + +/// For every function defined by XR_META_hand_tracking_frequency_hint in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_hand_tracking_frequency_hint(_) \ + _(SetHandTrackingFrequencyHintMETA, META_hand_tracking_frequency_hint) \ + + +/// For every function defined by XR_META_hand_tracking_wide_motion_mode2 in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_META_hand_tracking_wide_motion_mode2(_) + + +/// For every function defined by XR_ANDROID_light_estimation in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_light_estimation(_) \ + _(CreateLightEstimatorANDROID, ANDROID_light_estimation) \ + _(DestroyLightEstimatorANDROID, ANDROID_light_estimation) \ + _(GetLightEstimateANDROID, ANDROID_light_estimation) \ + + +/// For every function defined by XR_ANDROID_anchor_sharing_export in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_anchor_sharing_export(_) \ + _(ShareAnchorANDROID, ANDROID_anchor_sharing_export) \ + _(UnshareAnchorANDROID, ANDROID_anchor_sharing_export) \ + + +/// For every function defined by XR_ANDROID_mouse_interaction in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_mouse_interaction(_) + + +/// For every function defined by XR_ANDROID_trackables_marker in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_trackables_marker(_) \ + _(GetTrackableMarkerANDROID, ANDROID_trackables_marker) \ + + +/// For every function defined by XR_ANDROID_trackables_qr_code in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_trackables_qr_code(_) \ + _(GetTrackableQrCodeANDROID, ANDROID_trackables_qr_code) \ + + +/// For every function defined by XR_ANDROID_trackables_image in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_trackables_image(_) \ + _(CreateTrackableImageDatabaseAsyncANDROID, ANDROID_trackables_image) \ + _(CreateTrackableImageDatabaseCompleteANDROID, ANDROID_trackables_image) \ + _(DestroyTrackableImageDatabaseANDROID, ANDROID_trackables_image) \ + _(AddTrackableImageDatabaseANDROID, ANDROID_trackables_image) \ + _(RemoveTrackableImageDatabaseANDROID, ANDROID_trackables_image) \ + _(GetTrackableImageANDROID, ANDROID_trackables_image) \ + + +/// For every function defined by XR_ANDROID_scene_meshing in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_scene_meshing(_) \ + _(EnumerateSupportedSemanticLabelSetsANDROID, ANDROID_scene_meshing) \ + _(CreateSceneMeshingTrackerANDROID, ANDROID_scene_meshing) \ + _(DestroySceneMeshingTrackerANDROID, ANDROID_scene_meshing) \ + _(CreateSceneMeshSnapshotANDROID, ANDROID_scene_meshing) \ + _(DestroySceneMeshSnapshotANDROID, ANDROID_scene_meshing) \ + _(GetAllSubmeshStatesANDROID, ANDROID_scene_meshing) \ + _(GetSubmeshDataANDROID, ANDROID_scene_meshing) \ + + +/// For every function defined by XR_EXT_spatial_entity in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_spatial_entity(_) \ + _(EnumerateSpatialCapabilitiesEXT, EXT_spatial_entity) \ + _(EnumerateSpatialCapabilityComponentTypesEXT, EXT_spatial_entity) \ + _(EnumerateSpatialCapabilityFeaturesEXT, EXT_spatial_entity) \ + _(CreateSpatialContextAsyncEXT, EXT_spatial_entity) \ + _(CreateSpatialContextCompleteEXT, EXT_spatial_entity) \ + _(DestroySpatialContextEXT, EXT_spatial_entity) \ + _(CreateSpatialDiscoverySnapshotAsyncEXT, EXT_spatial_entity) \ + _(CreateSpatialDiscoverySnapshotCompleteEXT, EXT_spatial_entity) \ + _(QuerySpatialComponentDataEXT, EXT_spatial_entity) \ + _(DestroySpatialSnapshotEXT, EXT_spatial_entity) \ + _(CreateSpatialEntityFromIdEXT, EXT_spatial_entity) \ + _(DestroySpatialEntityEXT, EXT_spatial_entity) \ + _(CreateSpatialUpdateSnapshotEXT, EXT_spatial_entity) \ + _(GetSpatialBufferStringEXT, EXT_spatial_entity) \ + _(GetSpatialBufferUint8EXT, EXT_spatial_entity) \ + _(GetSpatialBufferUint16EXT, EXT_spatial_entity) \ + _(GetSpatialBufferUint32EXT, EXT_spatial_entity) \ + _(GetSpatialBufferFloatEXT, EXT_spatial_entity) \ + _(GetSpatialBufferVector2fEXT, EXT_spatial_entity) \ + _(GetSpatialBufferVector3fEXT, EXT_spatial_entity) \ + + +/// For every function defined by XR_EXT_spatial_plane_tracking in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_spatial_plane_tracking(_) + + +/// For every function defined by XR_EXT_stationary_reference_space in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_stationary_reference_space(_) \ + _(GetStationaryReferenceSpaceGenerationIdEXT, EXT_stationary_reference_space) \ + + +/// For every function defined by XR_EXT_spatial_marker_tracking in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_spatial_marker_tracking(_) + + +/// For every function defined by XR_LOGITECH_mx_ink_stylus_interaction in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_LOGITECH_mx_ink_stylus_interaction(_) + + +/// For every function defined by XR_BD_dynamic_object_tracking in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_BD_dynamic_object_tracking(_) + + +/// For every function defined by XR_BD_dynamic_object_keyboard in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_BD_dynamic_object_keyboard(_) + + +/// For every function defined by XR_BD_dynamic_object_mouse in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_BD_dynamic_object_mouse(_) + + +/// For every function defined by XR_BD_camera_image in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_BD_camera_image(_) \ + _(EnumerateAvailableCamerasBD, BD_camera_image) \ + _(EnumerateCameraPropertyTypesBD, BD_camera_image) \ + _(GetCameraPropertiesBD, BD_camera_image) \ + _(EnumerateCameraCapabilityTypesBD, BD_camera_image) \ + _(GetCameraSupportedCapabilitiesBD, BD_camera_image) \ + _(CreateCameraDeviceAsyncBD, BD_camera_image) \ + _(CreateCameraDeviceCompleteBD, BD_camera_image) \ + _(DestroyCameraDeviceBD, BD_camera_image) \ + _(CreateCameraCaptureSessionAsyncBD, BD_camera_image) \ + _(CreateCameraCaptureSessionCompleteBD, BD_camera_image) \ + _(DestroyCameraCaptureSessionBD, BD_camera_image) \ + _(BeginCameraCaptureBD, BD_camera_image) \ + _(EndCameraCaptureBD, BD_camera_image) \ + _(AcquireCameraImageBD, BD_camera_image) \ + _(GetCameraImageDataBD, BD_camera_image) \ + _(ReleaseCameraImageBD, BD_camera_image) \ + + +/// For every function defined by XR_ANDROID_spatial_discovery_bounds in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_spatial_discovery_bounds(_) + + +/// For every function defined by XR_EXT_spatial_anchor in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_spatial_anchor(_) \ + _(CreateSpatialAnchorEXT, EXT_spatial_anchor) \ + + +/// For every function defined by XR_EXT_spatial_persistence in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_spatial_persistence(_) \ + _(EnumerateSpatialPersistenceScopesEXT, EXT_spatial_persistence) \ + _(CreateSpatialPersistenceContextAsyncEXT, EXT_spatial_persistence) \ + _(CreateSpatialPersistenceContextCompleteEXT, EXT_spatial_persistence) \ + _(DestroySpatialPersistenceContextEXT, EXT_spatial_persistence) \ + + +/// For every function defined by XR_EXT_haptic_parametric in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_haptic_parametric(_) \ + _(HapticParametricGetPropertiesEXT, EXT_haptic_parametric) \ + + +/// For every function defined by XR_SONY_swapchain_color_space in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_SONY_swapchain_color_space(_) \ + _(EnumerateColorSpacesSONY, SONY_swapchain_color_space) \ + + +/// For every function defined by XR_SONY_hdr_metadata in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_SONY_hdr_metadata(_) \ + _(SetHdrMetadataSONY, SONY_hdr_metadata) \ + + +/// For every function defined by XR_EXT_spatial_persistence_operations in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_spatial_persistence_operations(_) \ + _(PersistSpatialEntityAsyncEXT, EXT_spatial_persistence_operations) \ + _(PersistSpatialEntityCompleteEXT, EXT_spatial_persistence_operations) \ + _(UnpersistSpatialEntityAsyncEXT, EXT_spatial_persistence_operations) \ + _(UnpersistSpatialEntityCompleteEXT, EXT_spatial_persistence_operations) \ + + +/// For every function defined by XR_EXT_spatial_image_tracking in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_spatial_image_tracking(_) \ + _(EnumerateSpatialReferenceImageFormatsEXT, EXT_spatial_image_tracking) \ + _(CreateSpatialImageTrackingDatabaseAsyncEXT, EXT_spatial_image_tracking) \ + _(CreateSpatialImageTrackingDatabaseCompleteEXT, EXT_spatial_image_tracking) \ + _(DestroySpatialImageTrackingDatabaseEXT, EXT_spatial_image_tracking) \ + + +/// For every function defined by XR_ANDROID_spatial_object_tracking in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_spatial_object_tracking(_) + + +/// For every function defined by XR_ANDROID_spatial_discovery_raycast in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_spatial_discovery_raycast(_) \ + _(CreateSpatialRaycastSnapshotANDROID, ANDROID_spatial_discovery_raycast) \ + + +/// For every function defined by XR_ANDROID_google_cloud_auth in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_google_cloud_auth(_) \ + _(SetGoogleCloudAuthAsyncANDROID, ANDROID_google_cloud_auth) \ + _(SetGoogleCloudAuthCompleteANDROID, ANDROID_google_cloud_auth) \ + + +/// For every function defined by XR_ANDROID_geospatial in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_geospatial(_) \ + _(CreateGeospatialTrackerANDROID, ANDROID_geospatial) \ + _(DestroyGeospatialTrackerANDROID, ANDROID_geospatial) \ + _(LocateGeospatialPoseFromPoseANDROID, ANDROID_geospatial) \ + _(LocateGeospatialPoseANDROID, ANDROID_geospatial) \ + _(CheckVpsAvailabilityAsyncANDROID, ANDROID_geospatial) \ + _(CheckVpsAvailabilityCompleteANDROID, ANDROID_geospatial) \ + + +/// For every function defined by XR_ANDROID_spatial_entity_bound_anchor in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_spatial_entity_bound_anchor(_) \ + _(EnumerateSpatialAnchorAttachableComponentsANDROID, ANDROID_spatial_entity_bound_anchor) \ + + +/// For every function defined by XR_ANDROID_spatial_component_subsumed_by in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_spatial_component_subsumed_by(_) + + +/// For every function defined by XR_ANDROID_spatial_anchor_space in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_spatial_anchor_space(_) \ + _(CreateSpatialAnchorSpaceANDROID, ANDROID_spatial_anchor_space) \ + _(CreateSpatialAnchorSpaceFromIdANDROID, ANDROID_spatial_anchor_space) \ + + +/// For every function defined by XR_ANDROID_geospatial_anchor in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_ANDROID_geospatial_anchor(_) \ + _(CreateGeospatialAnchorANDROID, ANDROID_geospatial_anchor) \ + _(CreateSurfaceAnchorAsyncANDROID, ANDROID_geospatial_anchor) \ + _(CreateSurfaceAnchorCompleteANDROID, ANDROID_geospatial_anchor) \ + + +/// For every function defined by XR_EXT_spatial_container in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_spatial_container(_) \ + _(CreateSpatialContainerEXT, EXT_spatial_container) \ + _(DestroySpatialContainerEXT, EXT_spatial_container) \ + _(CreateSpatialContainerSpaceEXT, EXT_spatial_container) \ + _(RequestSpatialContainerVisibleEXT, EXT_spatial_container) \ + _(RequestSpatialContainerBoundsModeEXT, EXT_spatial_container) \ + _(GetSpatialContainerBoundsEXT, EXT_spatial_container) \ + _(GetSpatialContainerStateEXT, EXT_spatial_container) \ + _(EnumerateSupportedSpatialContainerGraphicsPresentationsEXT, EXT_spatial_container) \ + + +/// For every function defined by XR_EXT_spatial_container_self_rendering in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_spatial_container_self_rendering(_) \ + _(BeginSpatialContainerRenderingEXT, EXT_spatial_container_self_rendering) \ + _(EndSpatialContainerRenderingEXT, EXT_spatial_container_self_rendering) \ + _(LocateSpatialContainerViewsEXT, EXT_spatial_container_self_rendering) \ + + +/// For every function defined by XR_EXT_interaction_profile_battery_state_display in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_interaction_profile_battery_state_display(_) + + +/// For every function defined by XR_EXT_loader_init_properties in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_loader_init_properties(_) + + +/// For every function defined by XR_EXT_view_configuration_views_change in this version of the spec, +/// calls your macro with the function name and extension name. +/// Trims the leading `xr` from the function name and the leading `XR_` from the feature name, +/// because it is easy to add back but impossible to remove with the preprocessor. +#define XR_LIST_FUNCTIONS_XR_EXT_view_configuration_views_change(_) + + + + +#endif + diff --git a/shadps4-arm64-main/externals/openxr-sdk/include/openxr/openxr_reflection_parent_structs.h b/shadps4-arm64-main/externals/openxr-sdk/include/openxr/openxr_reflection_parent_structs.h new file mode 100644 index 0000000..b4ff97c --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/include/openxr/openxr_reflection_parent_structs.h @@ -0,0 +1,516 @@ +#ifndef OPENXR_REFLECTION_PARENT_STRUCTS_H_ +#define OPENXR_REFLECTION_PARENT_STRUCTS_H_ 1 + +/* +** Copyright (c) 2017-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 OR MIT +*/ + +/* +** This header is generated from the Khronos OpenXR XML API Registry. +** +*/ + +#include "openxr.h" + +/* +This file contains expansion macros (X Macros) for OpenXR structures that have a parent type. +*/ + + +/// Like XR_LIST_ALL_STRUCTURE_TYPES, but only includes types whose parent struct type is XrCompositionLayerBaseHeader +#define XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrCompositionLayerBaseHeader(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrCompositionLayerBaseHeader_CORE(_avail, _unavail) \ + + +// Implementation detail of XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrCompositionLayerBaseHeader() +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrCompositionLayerBaseHeader_CORE(_avail, _unavail) \ + _avail(XrCompositionLayerProjection, XR_TYPE_COMPOSITION_LAYER_PROJECTION) \ + _avail(XrCompositionLayerQuad, XR_TYPE_COMPOSITION_LAYER_QUAD) \ + _avail(XrCompositionLayerCubeKHR, XR_TYPE_COMPOSITION_LAYER_CUBE_KHR) \ + _avail(XrCompositionLayerCylinderKHR, XR_TYPE_COMPOSITION_LAYER_CYLINDER_KHR) \ + _avail(XrCompositionLayerEquirectKHR, XR_TYPE_COMPOSITION_LAYER_EQUIRECT_KHR) \ + _avail(XrCompositionLayerEquirect2KHR, XR_TYPE_COMPOSITION_LAYER_EQUIRECT2_KHR) \ + _avail(XrCompositionLayerPassthroughFB, XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_FB) \ + _avail(XrCompositionLayerPassthroughHTC, XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_HTC) \ + _avail(XrCompositionLayerPassthroughANDROID, XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_ANDROID) \ + + + + + +/// Like XR_LIST_ALL_STRUCTURE_TYPES, but only includes types whose parent struct type is XrEventDataBaseHeader +#define XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrEventDataBaseHeader(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrEventDataBaseHeader_CORE(_avail, _unavail) \ + + +// Implementation detail of XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrEventDataBaseHeader() +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrEventDataBaseHeader_CORE(_avail, _unavail) \ + _avail(XrEventDataEventsLost, XR_TYPE_EVENT_DATA_EVENTS_LOST) \ + _avail(XrEventDataInstanceLossPending, XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING) \ + _avail(XrEventDataSessionStateChanged, XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED) \ + _avail(XrEventDataReferenceSpaceChangePending, XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING) \ + _avail(XrEventDataInteractionProfileChanged, XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED) \ + _avail(XrEventDataVisibilityMaskChangedKHR, XR_TYPE_EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR) \ + _avail(XrEventDataPerfSettingsEXT, XR_TYPE_EVENT_DATA_PERF_SETTINGS_EXT) \ + _avail(XrEventDataMainSessionVisibilityChangedEXTX, XR_TYPE_EVENT_DATA_MAIN_SESSION_VISIBILITY_CHANGED_EXTX) \ + _avail(XrEventDataDisplayRefreshRateChangedFB, XR_TYPE_EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB) \ + _avail(XrEventDataViveTrackerConnectedHTCX, XR_TYPE_EVENT_DATA_VIVE_TRACKER_CONNECTED_HTCX) \ + _avail(XrEventDataSpatialAnchorCreateCompleteFB, XR_TYPE_EVENT_DATA_SPATIAL_ANCHOR_CREATE_COMPLETE_FB) \ + _avail(XrEventDataSpaceSetStatusCompleteFB, XR_TYPE_EVENT_DATA_SPACE_SET_STATUS_COMPLETE_FB) \ + _avail(XrEventDataPassthroughStateChangedFB, XR_TYPE_EVENT_DATA_PASSTHROUGH_STATE_CHANGED_FB) \ + _avail(XrEventDataMarkerTrackingUpdateVARJO, XR_TYPE_EVENT_DATA_MARKER_TRACKING_UPDATE_VARJO) \ + _avail(XrEventDataLocalizationChangedML, XR_TYPE_EVENT_DATA_LOCALIZATION_CHANGED_ML) \ + _avail(XrEventDataSpaceQueryResultsAvailableFB, XR_TYPE_EVENT_DATA_SPACE_QUERY_RESULTS_AVAILABLE_FB) \ + _avail(XrEventDataSpaceQueryCompleteFB, XR_TYPE_EVENT_DATA_SPACE_QUERY_COMPLETE_FB) \ + _avail(XrEventDataSpaceSaveCompleteFB, XR_TYPE_EVENT_DATA_SPACE_SAVE_COMPLETE_FB) \ + _avail(XrEventDataSpaceEraseCompleteFB, XR_TYPE_EVENT_DATA_SPACE_ERASE_COMPLETE_FB) \ + _avail(XrEventDataSpaceShareCompleteFB, XR_TYPE_EVENT_DATA_SPACE_SHARE_COMPLETE_FB) \ + _avail(XrEventDataSceneCaptureCompleteFB, XR_TYPE_EVENT_DATA_SCENE_CAPTURE_COMPLETE_FB) \ + _avail(XrEventDataVirtualKeyboardCommitTextMETA, XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_COMMIT_TEXT_META) \ + _avail(XrEventDataVirtualKeyboardBackspaceMETA, XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_BACKSPACE_META) \ + _avail(XrEventDataVirtualKeyboardEnterMETA, XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_ENTER_META) \ + _avail(XrEventDataVirtualKeyboardShownMETA, XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_SHOWN_META) \ + _avail(XrEventDataVirtualKeyboardHiddenMETA, XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_HIDDEN_META) \ + _avail(XrEventDataSpaceListSaveCompleteFB, XR_TYPE_EVENT_DATA_SPACE_LIST_SAVE_COMPLETE_FB) \ + _avail(XrEventDataSpaceDiscoveryResultsAvailableMETA, XR_TYPE_EVENT_DATA_SPACE_DISCOVERY_RESULTS_AVAILABLE_META) \ + _avail(XrEventDataSpaceDiscoveryCompleteMETA, XR_TYPE_EVENT_DATA_SPACE_DISCOVERY_COMPLETE_META) \ + _avail(XrEventDataSpacesSaveResultMETA, XR_TYPE_EVENT_DATA_SPACES_SAVE_RESULT_META) \ + _avail(XrEventDataSpacesEraseResultMETA, XR_TYPE_EVENT_DATA_SPACES_ERASE_RESULT_META) \ + _avail(XrEventDataPassthroughLayerResumedMETA, XR_TYPE_EVENT_DATA_PASSTHROUGH_LAYER_RESUMED_META) \ + _avail(XrEventDataShareSpacesCompleteMETA, XR_TYPE_EVENT_DATA_SHARE_SPACES_COMPLETE_META) \ + _avail(XrEventDataInteractionRenderModelsChangedEXT, XR_TYPE_EVENT_DATA_INTERACTION_RENDER_MODELS_CHANGED_EXT) \ + _avail(XrEventDataSenseDataProviderStateChangedBD, XR_TYPE_EVENT_DATA_SENSE_DATA_PROVIDER_STATE_CHANGED_BD) \ + _avail(XrEventDataSenseDataUpdatedBD, XR_TYPE_EVENT_DATA_SENSE_DATA_UPDATED_BD) \ + _avail(XrEventDataRecommendedResolutionChangedANDROID, XR_TYPE_EVENT_DATA_RECOMMENDED_RESOLUTION_CHANGED_ANDROID) \ + _avail(XrEventDataUserPresenceChangedEXT, XR_TYPE_EVENT_DATA_USER_PRESENCE_CHANGED_EXT) \ + _avail(XrEventDataHeadsetFitChangedML, XR_TYPE_EVENT_DATA_HEADSET_FIT_CHANGED_ML) \ + _avail(XrEventDataEyeCalibrationChangedML, XR_TYPE_EVENT_DATA_EYE_CALIBRATION_CHANGED_ML) \ + _avail(XrEventDataBoundaryVisibilityChangedMETA, XR_TYPE_EVENT_DATA_BOUNDARY_VISIBILITY_CHANGED_META) \ + _avail(XrEventDataStartColocationAdvertisementCompleteMETA, XR_TYPE_EVENT_DATA_START_COLOCATION_ADVERTISEMENT_COMPLETE_META) \ + _avail(XrEventDataStopColocationAdvertisementCompleteMETA, XR_TYPE_EVENT_DATA_STOP_COLOCATION_ADVERTISEMENT_COMPLETE_META) \ + _avail(XrEventDataColocationAdvertisementCompleteMETA, XR_TYPE_EVENT_DATA_COLOCATION_ADVERTISEMENT_COMPLETE_META) \ + _avail(XrEventDataStartColocationDiscoveryCompleteMETA, XR_TYPE_EVENT_DATA_START_COLOCATION_DISCOVERY_COMPLETE_META) \ + _avail(XrEventDataColocationDiscoveryResultMETA, XR_TYPE_EVENT_DATA_COLOCATION_DISCOVERY_RESULT_META) \ + _avail(XrEventDataColocationDiscoveryCompleteMETA, XR_TYPE_EVENT_DATA_COLOCATION_DISCOVERY_COMPLETE_META) \ + _avail(XrEventDataStopColocationDiscoveryCompleteMETA, XR_TYPE_EVENT_DATA_STOP_COLOCATION_DISCOVERY_COMPLETE_META) \ + _avail(XrEventDataImageTrackingLostANDROID, XR_TYPE_EVENT_DATA_IMAGE_TRACKING_LOST_ANDROID) \ + _avail(XrEventDataSpatialDiscoveryRecommendedEXT, XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT) \ + _avail(XrEventDataGeospatialTrackerStateChangedANDROID, XR_TYPE_EVENT_DATA_GEOSPATIAL_TRACKER_STATE_CHANGED_ANDROID) \ + _avail(XrEventDataSpatialContainerClosedEXT, XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_CLOSED_EXT) \ + _avail(XrEventDataSpatialContainerBoundsChangedEXT, XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_BOUNDS_CHANGED_EXT) \ + _avail(XrEventDataSpatialContainerVisibleChangedEXT, XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_VISIBLE_CHANGED_EXT) \ + _avail(XrEventDataSpatialContainerVisibleRequestDeniedEXT, XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_VISIBLE_REQUEST_DENIED_EXT) \ + _avail(XrEventDataSpatialContainerInteractableChangedEXT, XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_INTERACTABLE_CHANGED_EXT) \ + _avail(XrEventDataSpatialContainerBoundsModeRequestDeniedEXT, XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_BOUNDS_MODE_REQUEST_DENIED_EXT) \ + _avail(XrEventDataViewConfigurationViewsChangedEXT, XR_TYPE_EVENT_DATA_VIEW_CONFIGURATION_VIEWS_CHANGED_EXT) \ + + + + + +/// Like XR_LIST_ALL_STRUCTURE_TYPES, but only includes types whose parent struct type is XrHapticBaseHeader +#define XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrHapticBaseHeader(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrHapticBaseHeader_CORE(_avail, _unavail) \ + + +// Implementation detail of XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrHapticBaseHeader() +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrHapticBaseHeader_CORE(_avail, _unavail) \ + _avail(XrHapticVibration, XR_TYPE_HAPTIC_VIBRATION) \ + _avail(XrHapticAmplitudeEnvelopeVibrationFB, XR_TYPE_HAPTIC_AMPLITUDE_ENVELOPE_VIBRATION_FB) \ + _avail(XrHapticPcmVibrationFB, XR_TYPE_HAPTIC_PCM_VIBRATION_FB) \ + _avail(XrHapticParametricVibrationEXT, XR_TYPE_HAPTIC_PARAMETRIC_VIBRATION_EXT) \ + + + + + +/// Like XR_LIST_ALL_STRUCTURE_TYPES, but only includes types whose parent struct type is XrSwapchainImageBaseHeader +#define XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainImageBaseHeader(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainImageBaseHeader_CORE(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainImageBaseHeader_XR_USE_GRAPHICS_API_D3D11(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainImageBaseHeader_XR_USE_GRAPHICS_API_D3D12(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainImageBaseHeader_XR_USE_GRAPHICS_API_METAL(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainImageBaseHeader_XR_USE_GRAPHICS_API_OPENGL(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainImageBaseHeader_XR_USE_GRAPHICS_API_OPENGL_ES(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainImageBaseHeader_XR_USE_GRAPHICS_API_VULKAN(_avail, _unavail) \ + + +// Implementation detail of XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainImageBaseHeader() +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainImageBaseHeader_CORE(_avail, _unavail) \ + + +#if defined(XR_USE_GRAPHICS_API_D3D11) +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainImageBaseHeader_XR_USE_GRAPHICS_API_D3D11(_avail, _unavail) \ + _avail(XrSwapchainImageD3D11KHR, XR_TYPE_SWAPCHAIN_IMAGE_D3D11_KHR) \ + +#else +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainImageBaseHeader_XR_USE_GRAPHICS_API_D3D11(_avail, _unavail) \ + _unavail(XrSwapchainImageD3D11KHR, XR_TYPE_SWAPCHAIN_IMAGE_D3D11_KHR) \ + +#endif + +#if defined(XR_USE_GRAPHICS_API_D3D12) +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainImageBaseHeader_XR_USE_GRAPHICS_API_D3D12(_avail, _unavail) \ + _avail(XrSwapchainImageD3D12KHR, XR_TYPE_SWAPCHAIN_IMAGE_D3D12_KHR) \ + +#else +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainImageBaseHeader_XR_USE_GRAPHICS_API_D3D12(_avail, _unavail) \ + _unavail(XrSwapchainImageD3D12KHR, XR_TYPE_SWAPCHAIN_IMAGE_D3D12_KHR) \ + +#endif + +#if defined(XR_USE_GRAPHICS_API_METAL) +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainImageBaseHeader_XR_USE_GRAPHICS_API_METAL(_avail, _unavail) \ + _avail(XrSwapchainImageMetalKHR, XR_TYPE_SWAPCHAIN_IMAGE_METAL_KHR) \ + +#else +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainImageBaseHeader_XR_USE_GRAPHICS_API_METAL(_avail, _unavail) \ + _unavail(XrSwapchainImageMetalKHR, XR_TYPE_SWAPCHAIN_IMAGE_METAL_KHR) \ + +#endif + +#if defined(XR_USE_GRAPHICS_API_OPENGL) +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainImageBaseHeader_XR_USE_GRAPHICS_API_OPENGL(_avail, _unavail) \ + _avail(XrSwapchainImageOpenGLKHR, XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_KHR) \ + +#else +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainImageBaseHeader_XR_USE_GRAPHICS_API_OPENGL(_avail, _unavail) \ + _unavail(XrSwapchainImageOpenGLKHR, XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_KHR) \ + +#endif + +#if defined(XR_USE_GRAPHICS_API_OPENGL_ES) +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainImageBaseHeader_XR_USE_GRAPHICS_API_OPENGL_ES(_avail, _unavail) \ + _avail(XrSwapchainImageOpenGLESKHR, XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR) \ + +#else +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainImageBaseHeader_XR_USE_GRAPHICS_API_OPENGL_ES(_avail, _unavail) \ + _unavail(XrSwapchainImageOpenGLESKHR, XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR) \ + +#endif + +#if defined(XR_USE_GRAPHICS_API_VULKAN) +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainImageBaseHeader_XR_USE_GRAPHICS_API_VULKAN(_avail, _unavail) \ + _avail(XrSwapchainImageVulkanKHR, XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR) \ + +#else +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainImageBaseHeader_XR_USE_GRAPHICS_API_VULKAN(_avail, _unavail) \ + _unavail(XrSwapchainImageVulkanKHR, XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR) \ + +#endif + + + + +/// Like XR_LIST_ALL_STRUCTURE_TYPES, but only includes types whose parent struct type is XrLoaderInitInfoBaseHeaderKHR +#define XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrLoaderInitInfoBaseHeaderKHR(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrLoaderInitInfoBaseHeaderKHR_CORE(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrLoaderInitInfoBaseHeaderKHR_XR_USE_PLATFORM_ANDROID(_avail, _unavail) \ + + +// Implementation detail of XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrLoaderInitInfoBaseHeaderKHR() +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrLoaderInitInfoBaseHeaderKHR_CORE(_avail, _unavail) \ + _avail(XrLoaderInitInfoPropertiesEXT, XR_TYPE_LOADER_INIT_INFO_PROPERTIES_EXT) \ + + +#if defined(XR_USE_PLATFORM_ANDROID) +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrLoaderInitInfoBaseHeaderKHR_XR_USE_PLATFORM_ANDROID(_avail, _unavail) \ + _avail(XrLoaderInitInfoAndroidKHR, XR_TYPE_LOADER_INIT_INFO_ANDROID_KHR) \ + +#else +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrLoaderInitInfoBaseHeaderKHR_XR_USE_PLATFORM_ANDROID(_avail, _unavail) \ + _unavail(XrLoaderInitInfoAndroidKHR, XR_TYPE_LOADER_INIT_INFO_ANDROID_KHR) \ + +#endif + + + + +/// Like XR_LIST_ALL_STRUCTURE_TYPES, but only includes types whose parent struct type is XrBindingModificationBaseHeaderKHR +#define XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrBindingModificationBaseHeaderKHR(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrBindingModificationBaseHeaderKHR_CORE(_avail, _unavail) \ + + +// Implementation detail of XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrBindingModificationBaseHeaderKHR() +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrBindingModificationBaseHeaderKHR_CORE(_avail, _unavail) \ + _avail(XrInteractionProfileDpadBindingEXT, XR_TYPE_INTERACTION_PROFILE_DPAD_BINDING_EXT) \ + _avail(XrInteractionProfileAnalogThresholdVALVE, XR_TYPE_INTERACTION_PROFILE_ANALOG_THRESHOLD_VALVE) \ + + + + + +/// Like XR_LIST_ALL_STRUCTURE_TYPES, but only includes types whose parent struct type is XrSwapchainStateBaseHeaderFB +#define XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainStateBaseHeaderFB(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainStateBaseHeaderFB_CORE(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainStateBaseHeaderFB_XR_USE_GRAPHICS_API_OPENGL_ES(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainStateBaseHeaderFB_XR_USE_GRAPHICS_API_VULKAN(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainStateBaseHeaderFB_XR_USE_PLATFORM_ANDROID(_avail, _unavail) \ + + +// Implementation detail of XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainStateBaseHeaderFB() +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainStateBaseHeaderFB_CORE(_avail, _unavail) \ + _avail(XrSwapchainStateFoveationFB, XR_TYPE_SWAPCHAIN_STATE_FOVEATION_FB) \ + + +#if defined(XR_USE_GRAPHICS_API_OPENGL_ES) +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainStateBaseHeaderFB_XR_USE_GRAPHICS_API_OPENGL_ES(_avail, _unavail) \ + _avail(XrSwapchainStateSamplerOpenGLESFB, XR_TYPE_SWAPCHAIN_STATE_SAMPLER_OPENGL_ES_FB) \ + +#else +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainStateBaseHeaderFB_XR_USE_GRAPHICS_API_OPENGL_ES(_avail, _unavail) \ + _unavail(XrSwapchainStateSamplerOpenGLESFB, XR_TYPE_SWAPCHAIN_STATE_SAMPLER_OPENGL_ES_FB) \ + +#endif + +#if defined(XR_USE_GRAPHICS_API_VULKAN) +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainStateBaseHeaderFB_XR_USE_GRAPHICS_API_VULKAN(_avail, _unavail) \ + _avail(XrSwapchainStateSamplerVulkanFB, XR_TYPE_SWAPCHAIN_STATE_SAMPLER_VULKAN_FB) \ + +#else +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainStateBaseHeaderFB_XR_USE_GRAPHICS_API_VULKAN(_avail, _unavail) \ + _unavail(XrSwapchainStateSamplerVulkanFB, XR_TYPE_SWAPCHAIN_STATE_SAMPLER_VULKAN_FB) \ + +#endif + +#if defined(XR_USE_PLATFORM_ANDROID) +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainStateBaseHeaderFB_XR_USE_PLATFORM_ANDROID(_avail, _unavail) \ + _avail(XrSwapchainStateAndroidSurfaceDimensionsFB, XR_TYPE_SWAPCHAIN_STATE_ANDROID_SURFACE_DIMENSIONS_FB) \ + +#else +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSwapchainStateBaseHeaderFB_XR_USE_PLATFORM_ANDROID(_avail, _unavail) \ + _unavail(XrSwapchainStateAndroidSurfaceDimensionsFB, XR_TYPE_SWAPCHAIN_STATE_ANDROID_SURFACE_DIMENSIONS_FB) \ + +#endif + + + + +/// Like XR_LIST_ALL_STRUCTURE_TYPES, but only includes types whose parent struct type is XrSpatialAnchorsCreateInfoBaseHeaderML +#define XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpatialAnchorsCreateInfoBaseHeaderML(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpatialAnchorsCreateInfoBaseHeaderML_CORE(_avail, _unavail) \ + + +// Implementation detail of XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpatialAnchorsCreateInfoBaseHeaderML() +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpatialAnchorsCreateInfoBaseHeaderML_CORE(_avail, _unavail) \ + _avail(XrSpatialAnchorsCreateInfoFromPoseML, XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_POSE_ML) \ + _avail(XrSpatialAnchorsCreateInfoFromUuidsML, XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_UUIDS_ML) \ + + + + + +/// Like XR_LIST_ALL_STRUCTURE_TYPES, but only includes types whose parent struct type is XrFutureCompletionBaseHeaderEXT +#define XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrFutureCompletionBaseHeaderEXT(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrFutureCompletionBaseHeaderEXT_CORE(_avail, _unavail) \ + + +// Implementation detail of XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrFutureCompletionBaseHeaderEXT() +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrFutureCompletionBaseHeaderEXT_CORE(_avail, _unavail) \ + _avail(XrCreateSpatialAnchorsCompletionML, XR_TYPE_CREATE_SPATIAL_ANCHORS_COMPLETION_ML) \ + _avail(XrSpatialAnchorsQueryCompletionML, XR_TYPE_SPATIAL_ANCHORS_QUERY_COMPLETION_ML) \ + _avail(XrSpatialAnchorsPublishCompletionML, XR_TYPE_SPATIAL_ANCHORS_PUBLISH_COMPLETION_ML) \ + _avail(XrSpatialAnchorsDeleteCompletionML, XR_TYPE_SPATIAL_ANCHORS_DELETE_COMPLETION_ML) \ + _avail(XrSpatialAnchorsUpdateExpirationCompletionML, XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_COMPLETION_ML) \ + _avail(XrSenseDataQueryCompletionBD, XR_TYPE_SENSE_DATA_QUERY_COMPLETION_BD) \ + _avail(XrFutureCompletionEXT, XR_TYPE_FUTURE_COMPLETION_EXT) \ + _avail(XrSpatialAnchorCreateCompletionBD, XR_TYPE_SPATIAL_ANCHOR_CREATE_COMPLETION_BD) \ + _avail(XrWorldMeshStateRequestCompletionML, XR_TYPE_WORLD_MESH_STATE_REQUEST_COMPLETION_ML) \ + _avail(XrWorldMeshRequestCompletionML, XR_TYPE_WORLD_MESH_REQUEST_COMPLETION_ML) \ + _avail(XrEnvironmentRaycasterCreateCompletionMETA, XR_TYPE_ENVIRONMENT_RAYCASTER_CREATE_COMPLETION_META) \ + _avail(XrCreateTrackableImageDatabaseCompletionANDROID, XR_TYPE_CREATE_TRACKABLE_IMAGE_DATABASE_COMPLETION_ANDROID) \ + _avail(XrCreateSpatialContextCompletionEXT, XR_TYPE_CREATE_SPATIAL_CONTEXT_COMPLETION_EXT) \ + _avail(XrCreateSpatialDiscoverySnapshotCompletionEXT, XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_EXT) \ + _avail(XrCreateCameraDeviceCompletionBD, XR_TYPE_CREATE_CAMERA_DEVICE_COMPLETION_BD) \ + _avail(XrCreateCameraCaptureSessionCompletionBD, XR_TYPE_CREATE_CAMERA_CAPTURE_SESSION_COMPLETION_BD) \ + _avail(XrCreateSpatialPersistenceContextCompletionEXT, XR_TYPE_CREATE_SPATIAL_PERSISTENCE_CONTEXT_COMPLETION_EXT) \ + _avail(XrPersistSpatialEntityCompletionEXT, XR_TYPE_PERSIST_SPATIAL_ENTITY_COMPLETION_EXT) \ + _avail(XrUnpersistSpatialEntityCompletionEXT, XR_TYPE_UNPERSIST_SPATIAL_ENTITY_COMPLETION_EXT) \ + _avail(XrCreateSpatialImageTrackingDatabaseCompletionEXT, XR_TYPE_CREATE_SPATIAL_IMAGE_TRACKING_DATABASE_COMPLETION_EXT) \ + _avail(XrVPSAvailabilityCheckCompletionANDROID, XR_TYPE_VPS_AVAILABILITY_CHECK_COMPLETION_ANDROID) \ + _avail(XrSurfaceAnchorCreateCompletionANDROID, XR_TYPE_SURFACE_ANCHOR_CREATE_COMPLETION_ANDROID) \ + + + + + +/// Like XR_LIST_ALL_STRUCTURE_TYPES, but only includes types whose parent struct type is XrSpatialAnchorsQueryInfoBaseHeaderML +#define XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpatialAnchorsQueryInfoBaseHeaderML(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpatialAnchorsQueryInfoBaseHeaderML_CORE(_avail, _unavail) \ + + +// Implementation detail of XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpatialAnchorsQueryInfoBaseHeaderML() +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpatialAnchorsQueryInfoBaseHeaderML_CORE(_avail, _unavail) \ + _avail(XrSpatialAnchorsQueryInfoRadiusML, XR_TYPE_SPATIAL_ANCHORS_QUERY_INFO_RADIUS_ML) \ + + + + + +/// Like XR_LIST_ALL_STRUCTURE_TYPES, but only includes types whose parent struct type is XrSpaceQueryInfoBaseHeaderFB +#define XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpaceQueryInfoBaseHeaderFB(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpaceQueryInfoBaseHeaderFB_CORE(_avail, _unavail) \ + + +// Implementation detail of XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpaceQueryInfoBaseHeaderFB() +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpaceQueryInfoBaseHeaderFB_CORE(_avail, _unavail) \ + _avail(XrSpaceQueryInfoFB, XR_TYPE_SPACE_QUERY_INFO_FB) \ + + + + + +/// Like XR_LIST_ALL_STRUCTURE_TYPES, but only includes types whose parent struct type is XrSpaceFilterInfoBaseHeaderFB +#define XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpaceFilterInfoBaseHeaderFB(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpaceFilterInfoBaseHeaderFB_CORE(_avail, _unavail) \ + + +// Implementation detail of XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpaceFilterInfoBaseHeaderFB() +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpaceFilterInfoBaseHeaderFB_CORE(_avail, _unavail) \ + _avail(XrSpaceUuidFilterInfoFB, XR_TYPE_SPACE_UUID_FILTER_INFO_FB) \ + _avail(XrSpaceComponentFilterInfoFB, XR_TYPE_SPACE_COMPONENT_FILTER_INFO_FB) \ + + + + + +/// Like XR_LIST_ALL_STRUCTURE_TYPES, but only includes types whose parent struct type is XrSpaceFilterBaseHeaderMETA +#define XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpaceFilterBaseHeaderMETA(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpaceFilterBaseHeaderMETA_CORE(_avail, _unavail) \ + + +// Implementation detail of XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpaceFilterBaseHeaderMETA() +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpaceFilterBaseHeaderMETA_CORE(_avail, _unavail) \ + _avail(XrSpaceFilterUuidMETA, XR_TYPE_SPACE_FILTER_UUID_META) \ + _avail(XrSpaceFilterComponentMETA, XR_TYPE_SPACE_FILTER_COMPONENT_META) \ + + + + + +/// Like XR_LIST_ALL_STRUCTURE_TYPES, but only includes types whose parent struct type is XrShareSpacesRecipientBaseHeaderMETA +#define XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrShareSpacesRecipientBaseHeaderMETA(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrShareSpacesRecipientBaseHeaderMETA_CORE(_avail, _unavail) \ + + +// Implementation detail of XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrShareSpacesRecipientBaseHeaderMETA() +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrShareSpacesRecipientBaseHeaderMETA_CORE(_avail, _unavail) \ + _avail(XrShareSpacesRecipientGroupsMETA, XR_TYPE_SHARE_SPACES_RECIPIENT_GROUPS_META) \ + + + + + +/// Like XR_LIST_ALL_STRUCTURE_TYPES, but only includes types whose parent struct type is XrEnvironmentRaycastFilterBaseHeaderMETA +#define XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrEnvironmentRaycastFilterBaseHeaderMETA(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrEnvironmentRaycastFilterBaseHeaderMETA_CORE(_avail, _unavail) \ + + +// Implementation detail of XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrEnvironmentRaycastFilterBaseHeaderMETA() +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrEnvironmentRaycastFilterBaseHeaderMETA_CORE(_avail, _unavail) \ + _avail(XrEnvironmentRaycastFilterDistanceMETA, XR_TYPE_ENVIRONMENT_RAYCAST_FILTER_DISTANCE_META) \ + + + + + +/// Like XR_LIST_ALL_STRUCTURE_TYPES, but only includes types whose parent struct type is XrSpatialCapabilityConfigurationBaseHeaderEXT +#define XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpatialCapabilityConfigurationBaseHeaderEXT(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpatialCapabilityConfigurationBaseHeaderEXT_CORE(_avail, _unavail) \ + + +// Implementation detail of XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpatialCapabilityConfigurationBaseHeaderEXT() +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrSpatialCapabilityConfigurationBaseHeaderEXT_CORE(_avail, _unavail) \ + _avail(XrSpatialCapabilityConfigurationPlaneTrackingEXT, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_PLANE_TRACKING_EXT) \ + _avail(XrSpatialCapabilityConfigurationQrCodeEXT, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_QR_CODE_EXT) \ + _avail(XrSpatialCapabilityConfigurationMicroQrCodeEXT, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_MICRO_QR_CODE_EXT) \ + _avail(XrSpatialCapabilityConfigurationArucoMarkerEXT, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ARUCO_MARKER_EXT) \ + _avail(XrSpatialCapabilityConfigurationAprilTagEXT, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_APRIL_TAG_EXT) \ + _avail(XrSpatialCapabilityConfigurationAnchorEXT, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ANCHOR_EXT) \ + _avail(XrSpatialCapabilityConfigurationImageTrackingEXT, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_IMAGE_TRACKING_EXT) \ + _avail(XrSpatialCapabilityConfigurationObjectTrackingANDROID, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_OBJECT_TRACKING_ANDROID) \ + _avail(XrSpatialCapabilityConfigurationDepthRaycastANDROID, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_DEPTH_RAYCAST_ANDROID) \ + + + + + +/// Like XR_LIST_ALL_STRUCTURE_TYPES, but only includes types whose parent struct type is XrCameraPropertyBaseHeaderBD +#define XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrCameraPropertyBaseHeaderBD(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrCameraPropertyBaseHeaderBD_CORE(_avail, _unavail) \ + + +// Implementation detail of XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrCameraPropertyBaseHeaderBD() +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrCameraPropertyBaseHeaderBD_CORE(_avail, _unavail) \ + _avail(XrCameraPropertyFacingBD, XR_TYPE_CAMERA_PROPERTY_FACING_BD) \ + _avail(XrCameraPropertyPositionBD, XR_TYPE_CAMERA_PROPERTY_POSITION_BD) \ + _avail(XrCameraPropertyCameraTypeBD, XR_TYPE_CAMERA_PROPERTY_CAMERA_TYPE_BD) \ + + + + + +/// Like XR_LIST_ALL_STRUCTURE_TYPES, but only includes types whose parent struct type is XrCameraSupportedCapabilityBaseHeaderBD +#define XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrCameraSupportedCapabilityBaseHeaderBD(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrCameraSupportedCapabilityBaseHeaderBD_CORE(_avail, _unavail) \ + + +// Implementation detail of XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrCameraSupportedCapabilityBaseHeaderBD() +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrCameraSupportedCapabilityBaseHeaderBD_CORE(_avail, _unavail) \ + _avail(XrCameraSupportedCapabilityImageResolutionAndFrameRateBD, XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_IMAGE_RESOLUTION_AND_FRAME_RATE_BD) \ + _avail(XrCameraSupportedCapabilityDataTransferTypeBD, XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_DATA_TRANSFER_TYPE_BD) \ + _avail(XrCameraSupportedCapabilityImageFormatBD, XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_IMAGE_FORMAT_BD) \ + _avail(XrCameraSupportedCapabilityCameraModelBD, XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_CAMERA_MODEL_BD) \ + + + + + +/// Like XR_LIST_ALL_STRUCTURE_TYPES, but only includes types whose parent struct type is XrCameraCapabilityBaseHeaderBD +#define XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrCameraCapabilityBaseHeaderBD(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrCameraCapabilityBaseHeaderBD_CORE(_avail, _unavail) \ + + +// Implementation detail of XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrCameraCapabilityBaseHeaderBD() +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrCameraCapabilityBaseHeaderBD_CORE(_avail, _unavail) \ + _avail(XrCameraCapabilityImageResolutionAndFrameRateBD, XR_TYPE_CAMERA_CAPABILITY_IMAGE_RESOLUTION_AND_FRAME_RATE_BD) \ + _avail(XrCameraCapabilityDataTransferTypeBD, XR_TYPE_CAMERA_CAPABILITY_DATA_TRANSFER_TYPE_BD) \ + _avail(XrCameraCapabilityImageFormatBD, XR_TYPE_CAMERA_CAPABILITY_IMAGE_FORMAT_BD) \ + _avail(XrCameraCapabilityCameraModelBD, XR_TYPE_CAMERA_CAPABILITY_CAMERA_MODEL_BD) \ + + + + + +/// Like XR_LIST_ALL_STRUCTURE_TYPES, but only includes types whose parent struct type is XrCameraImageDataBaseHeaderBD +#define XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrCameraImageDataBaseHeaderBD(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrCameraImageDataBaseHeaderBD_CORE(_avail, _unavail) \ + + +// Implementation detail of XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrCameraImageDataBaseHeaderBD() +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrCameraImageDataBaseHeaderBD_CORE(_avail, _unavail) \ + _avail(XrCameraImageDataRawBufferBD, XR_TYPE_CAMERA_IMAGE_DATA_RAW_BUFFER_BD) \ + + + + + +/// Like XR_LIST_ALL_STRUCTURE_TYPES, but only includes types whose parent struct type is XrGoogleCloudAuthInfoBaseHeaderANDROID +#define XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrGoogleCloudAuthInfoBaseHeaderANDROID(_avail, _unavail) \ + _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrGoogleCloudAuthInfoBaseHeaderANDROID_CORE(_avail, _unavail) \ + + +// Implementation detail of XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrGoogleCloudAuthInfoBaseHeaderANDROID() +#define _impl_XR_LIST_ALL_CHILD_STRUCTURE_TYPES_XrGoogleCloudAuthInfoBaseHeaderANDROID_CORE(_avail, _unavail) \ + _avail(XrGoogleCloudAuthInfoApiKeyANDROID, XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_API_KEY_ANDROID) \ + _avail(XrGoogleCloudAuthInfoTokenANDROID, XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_TOKEN_ANDROID) \ + _avail(XrGoogleCloudAuthInfoKeylessANDROID, XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_KEYLESS_ANDROID) \ + + + + + +#endif + diff --git a/shadps4-arm64-main/externals/openxr-sdk/include/openxr/openxr_reflection_structs.h b/shadps4-arm64-main/externals/openxr-sdk/include/openxr/openxr_reflection_structs.h new file mode 100644 index 0000000..fe445df --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/include/openxr/openxr_reflection_structs.h @@ -0,0 +1,963 @@ +#ifndef OPENXR_REFLECTION_STRUCTS_H_ +#define OPENXR_REFLECTION_STRUCTS_H_ 1 + +/* +** Copyright (c) 2017-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 OR MIT +*/ + +/* +** This header is generated from the Khronos OpenXR XML API Registry. +** +*/ + +#include "openxr.h" + +/* +This file contains expansion macros (X Macros) for OpenXR structures. +*/ + + + +/// Calls one of your macros with the structure type name and the XrStructureType constant for +/// each known structure type. The first macro (_avail) is called for those that are available, +/// while the second macro (_unavail) is called for those unavailable due to preprocessor definitions. +#define XR_LIST_ALL_STRUCTURE_TYPES(_avail, _unavail) \ + _impl_XR_LIST_ALL_STRUCTURE_TYPES_CORE(_avail, _unavail) \ + _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_D3D11(_avail, _unavail) \ + _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_D3D12(_avail, _unavail) \ + _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_METAL(_avail, _unavail) \ + _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL(_avail, _unavail) \ + _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_WAYLAND(_avail, _unavail) \ + _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_WIN32(_avail, _unavail) \ + _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_XCB(_avail, _unavail) \ + _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_XLIB(_avail, _unavail) \ + _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_ES(_avail, _unavail) \ + _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_ES_XR_USE_PLATFORM_ANDROID(_avail, _unavail) \ + _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_VULKAN(_avail, _unavail) \ + _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_PLATFORM_ANDROID(_avail, _unavail) \ + _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_PLATFORM_EGL(_avail, _unavail) \ + _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_PLATFORM_ML(_avail, _unavail) \ + _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_PLATFORM_WIN32(_avail, _unavail) \ + + +// Implementation detail of XR_LIST_ALL_STRUCTURE_TYPES() +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_CORE(_avail, _unavail) \ + _avail(XrApiLayerProperties, XR_TYPE_API_LAYER_PROPERTIES) \ + _avail(XrExtensionProperties, XR_TYPE_EXTENSION_PROPERTIES) \ + _avail(XrInstanceCreateInfo, XR_TYPE_INSTANCE_CREATE_INFO) \ + _avail(XrInstanceProperties, XR_TYPE_INSTANCE_PROPERTIES) \ + _avail(XrEventDataBuffer, XR_TYPE_EVENT_DATA_BUFFER) \ + _avail(XrSystemGetInfo, XR_TYPE_SYSTEM_GET_INFO) \ + _avail(XrSystemProperties, XR_TYPE_SYSTEM_PROPERTIES) \ + _avail(XrSessionCreateInfo, XR_TYPE_SESSION_CREATE_INFO) \ + _avail(XrReferenceSpaceCreateInfo, XR_TYPE_REFERENCE_SPACE_CREATE_INFO) \ + _avail(XrActionSpaceCreateInfo, XR_TYPE_ACTION_SPACE_CREATE_INFO) \ + _avail(XrSpaceLocation, XR_TYPE_SPACE_LOCATION) \ + _avail(XrSpaceVelocity, XR_TYPE_SPACE_VELOCITY) \ + _avail(XrViewConfigurationProperties, XR_TYPE_VIEW_CONFIGURATION_PROPERTIES) \ + _avail(XrViewConfigurationView, XR_TYPE_VIEW_CONFIGURATION_VIEW) \ + _avail(XrSwapchainCreateInfo, XR_TYPE_SWAPCHAIN_CREATE_INFO) \ + _avail(XrSwapchainImageAcquireInfo, XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO) \ + _avail(XrSwapchainImageWaitInfo, XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO) \ + _avail(XrSwapchainImageReleaseInfo, XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO) \ + _avail(XrSessionBeginInfo, XR_TYPE_SESSION_BEGIN_INFO) \ + _avail(XrFrameState, XR_TYPE_FRAME_STATE) \ + _avail(XrFrameWaitInfo, XR_TYPE_FRAME_WAIT_INFO) \ + _avail(XrFrameBeginInfo, XR_TYPE_FRAME_BEGIN_INFO) \ + _avail(XrFrameEndInfo, XR_TYPE_FRAME_END_INFO) \ + _avail(XrViewState, XR_TYPE_VIEW_STATE) \ + _avail(XrViewLocateInfo, XR_TYPE_VIEW_LOCATE_INFO) \ + _avail(XrView, XR_TYPE_VIEW) \ + _avail(XrActionSetCreateInfo, XR_TYPE_ACTION_SET_CREATE_INFO) \ + _avail(XrActionCreateInfo, XR_TYPE_ACTION_CREATE_INFO) \ + _avail(XrInteractionProfileSuggestedBinding, XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING) \ + _avail(XrSessionActionSetsAttachInfo, XR_TYPE_SESSION_ACTION_SETS_ATTACH_INFO) \ + _avail(XrInteractionProfileState, XR_TYPE_INTERACTION_PROFILE_STATE) \ + _avail(XrActionStateGetInfo, XR_TYPE_ACTION_STATE_GET_INFO) \ + _avail(XrActionStateBoolean, XR_TYPE_ACTION_STATE_BOOLEAN) \ + _avail(XrActionStateFloat, XR_TYPE_ACTION_STATE_FLOAT) \ + _avail(XrActionStateVector2f, XR_TYPE_ACTION_STATE_VECTOR2F) \ + _avail(XrActionStatePose, XR_TYPE_ACTION_STATE_POSE) \ + _avail(XrActionsSyncInfo, XR_TYPE_ACTIONS_SYNC_INFO) \ + _avail(XrBoundSourcesForActionEnumerateInfo, XR_TYPE_BOUND_SOURCES_FOR_ACTION_ENUMERATE_INFO) \ + _avail(XrInputSourceLocalizedNameGetInfo, XR_TYPE_INPUT_SOURCE_LOCALIZED_NAME_GET_INFO) \ + _avail(XrHapticActionInfo, XR_TYPE_HAPTIC_ACTION_INFO) \ + _avail(XrCompositionLayerProjectionView, XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW) \ + _avail(XrCompositionLayerProjection, XR_TYPE_COMPOSITION_LAYER_PROJECTION) \ + _avail(XrCompositionLayerQuad, XR_TYPE_COMPOSITION_LAYER_QUAD) \ + _avail(XrEventDataEventsLost, XR_TYPE_EVENT_DATA_EVENTS_LOST) \ + _avail(XrEventDataInstanceLossPending, XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING) \ + _avail(XrEventDataSessionStateChanged, XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED) \ + _avail(XrEventDataReferenceSpaceChangePending, XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING) \ + _avail(XrEventDataInteractionProfileChanged, XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED) \ + _avail(XrHapticVibration, XR_TYPE_HAPTIC_VIBRATION) \ + _avail(XrSpacesLocateInfo, XR_TYPE_SPACES_LOCATE_INFO) \ + _avail(XrSpaceLocations, XR_TYPE_SPACE_LOCATIONS) \ + _avail(XrSpaceVelocities, XR_TYPE_SPACE_VELOCITIES) \ + _avail(XrCompositionLayerCubeKHR, XR_TYPE_COMPOSITION_LAYER_CUBE_KHR) \ + _avail(XrCompositionLayerDepthInfoKHR, XR_TYPE_COMPOSITION_LAYER_DEPTH_INFO_KHR) \ + _avail(XrCompositionLayerCylinderKHR, XR_TYPE_COMPOSITION_LAYER_CYLINDER_KHR) \ + _avail(XrCompositionLayerEquirectKHR, XR_TYPE_COMPOSITION_LAYER_EQUIRECT_KHR) \ + _avail(XrVisibilityMaskKHR, XR_TYPE_VISIBILITY_MASK_KHR) \ + _avail(XrEventDataVisibilityMaskChangedKHR, XR_TYPE_EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR) \ + _avail(XrCompositionLayerColorScaleBiasKHR, XR_TYPE_COMPOSITION_LAYER_COLOR_SCALE_BIAS_KHR) \ + _avail(XrCompositionLayerEquirect2KHR, XR_TYPE_COMPOSITION_LAYER_EQUIRECT2_KHR) \ + _avail(XrBindingModificationsKHR, XR_TYPE_BINDING_MODIFICATIONS_KHR) \ + _avail(XrEventDataPerfSettingsEXT, XR_TYPE_EVENT_DATA_PERF_SETTINGS_EXT) \ + _avail(XrDebugUtilsObjectNameInfoEXT, XR_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT) \ + _avail(XrDebugUtilsLabelEXT, XR_TYPE_DEBUG_UTILS_LABEL_EXT) \ + _avail(XrDebugUtilsMessengerCallbackDataEXT, XR_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT) \ + _avail(XrDebugUtilsMessengerCreateInfoEXT, XR_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT) \ + _avail(XrSystemEyeGazeInteractionPropertiesEXT, XR_TYPE_SYSTEM_EYE_GAZE_INTERACTION_PROPERTIES_EXT) \ + _avail(XrEyeGazeSampleTimeEXT, XR_TYPE_EYE_GAZE_SAMPLE_TIME_EXT) \ + _avail(XrSessionCreateInfoOverlayEXTX, XR_TYPE_SESSION_CREATE_INFO_OVERLAY_EXTX) \ + _avail(XrEventDataMainSessionVisibilityChangedEXTX, XR_TYPE_EVENT_DATA_MAIN_SESSION_VISIBILITY_CHANGED_EXTX) \ + _avail(XrSpatialAnchorCreateInfoMSFT, XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_MSFT) \ + _avail(XrSpatialAnchorSpaceCreateInfoMSFT, XR_TYPE_SPATIAL_ANCHOR_SPACE_CREATE_INFO_MSFT) \ + _avail(XrCompositionLayerImageLayoutFB, XR_TYPE_COMPOSITION_LAYER_IMAGE_LAYOUT_FB) \ + _avail(XrCompositionLayerAlphaBlendFB, XR_TYPE_COMPOSITION_LAYER_ALPHA_BLEND_FB) \ + _avail(XrViewConfigurationDepthRangeEXT, XR_TYPE_VIEW_CONFIGURATION_DEPTH_RANGE_EXT) \ + _avail(XrSpatialGraphNodeSpaceCreateInfoMSFT, XR_TYPE_SPATIAL_GRAPH_NODE_SPACE_CREATE_INFO_MSFT) \ + _avail(XrSpatialGraphStaticNodeBindingCreateInfoMSFT, XR_TYPE_SPATIAL_GRAPH_STATIC_NODE_BINDING_CREATE_INFO_MSFT) \ + _avail(XrSpatialGraphNodeBindingPropertiesGetInfoMSFT, XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_GET_INFO_MSFT) \ + _avail(XrSpatialGraphNodeBindingPropertiesMSFT, XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_MSFT) \ + _avail(XrSystemHandTrackingPropertiesEXT, XR_TYPE_SYSTEM_HAND_TRACKING_PROPERTIES_EXT) \ + _avail(XrHandTrackerCreateInfoEXT, XR_TYPE_HAND_TRACKER_CREATE_INFO_EXT) \ + _avail(XrHandJointsLocateInfoEXT, XR_TYPE_HAND_JOINTS_LOCATE_INFO_EXT) \ + _avail(XrHandJointLocationsEXT, XR_TYPE_HAND_JOINT_LOCATIONS_EXT) \ + _avail(XrHandJointVelocitiesEXT, XR_TYPE_HAND_JOINT_VELOCITIES_EXT) \ + _avail(XrSystemHandTrackingMeshPropertiesMSFT, XR_TYPE_SYSTEM_HAND_TRACKING_MESH_PROPERTIES_MSFT) \ + _avail(XrHandMeshSpaceCreateInfoMSFT, XR_TYPE_HAND_MESH_SPACE_CREATE_INFO_MSFT) \ + _avail(XrHandMeshUpdateInfoMSFT, XR_TYPE_HAND_MESH_UPDATE_INFO_MSFT) \ + _avail(XrHandMeshMSFT, XR_TYPE_HAND_MESH_MSFT) \ + _avail(XrHandPoseTypeInfoMSFT, XR_TYPE_HAND_POSE_TYPE_INFO_MSFT) \ + _avail(XrSecondaryViewConfigurationSessionBeginInfoMSFT, XR_TYPE_SECONDARY_VIEW_CONFIGURATION_SESSION_BEGIN_INFO_MSFT) \ + _avail(XrSecondaryViewConfigurationStateMSFT, XR_TYPE_SECONDARY_VIEW_CONFIGURATION_STATE_MSFT) \ + _avail(XrSecondaryViewConfigurationFrameStateMSFT, XR_TYPE_SECONDARY_VIEW_CONFIGURATION_FRAME_STATE_MSFT) \ + _avail(XrSecondaryViewConfigurationLayerInfoMSFT, XR_TYPE_SECONDARY_VIEW_CONFIGURATION_LAYER_INFO_MSFT) \ + _avail(XrSecondaryViewConfigurationFrameEndInfoMSFT, XR_TYPE_SECONDARY_VIEW_CONFIGURATION_FRAME_END_INFO_MSFT) \ + _avail(XrSecondaryViewConfigurationSwapchainCreateInfoMSFT, XR_TYPE_SECONDARY_VIEW_CONFIGURATION_SWAPCHAIN_CREATE_INFO_MSFT) \ + _avail(XrControllerModelKeyStateMSFT, XR_TYPE_CONTROLLER_MODEL_KEY_STATE_MSFT) \ + _avail(XrControllerModelNodePropertiesMSFT, XR_TYPE_CONTROLLER_MODEL_NODE_PROPERTIES_MSFT) \ + _avail(XrControllerModelPropertiesMSFT, XR_TYPE_CONTROLLER_MODEL_PROPERTIES_MSFT) \ + _avail(XrControllerModelNodeStateMSFT, XR_TYPE_CONTROLLER_MODEL_NODE_STATE_MSFT) \ + _avail(XrControllerModelStateMSFT, XR_TYPE_CONTROLLER_MODEL_STATE_MSFT) \ + _avail(XrViewConfigurationViewFovEPIC, XR_TYPE_VIEW_CONFIGURATION_VIEW_FOV_EPIC) \ + _avail(XrCompositionLayerReprojectionInfoMSFT, XR_TYPE_COMPOSITION_LAYER_REPROJECTION_INFO_MSFT) \ + _avail(XrCompositionLayerReprojectionPlaneOverrideMSFT, XR_TYPE_COMPOSITION_LAYER_REPROJECTION_PLANE_OVERRIDE_MSFT) \ + _avail(XrCompositionLayerSecureContentFB, XR_TYPE_COMPOSITION_LAYER_SECURE_CONTENT_FB) \ + _avail(XrSystemBodyTrackingPropertiesFB, XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_FB) \ + _avail(XrBodyTrackerCreateInfoFB, XR_TYPE_BODY_TRACKER_CREATE_INFO_FB) \ + _avail(XrBodySkeletonFB, XR_TYPE_BODY_SKELETON_FB) \ + _avail(XrBodyJointsLocateInfoFB, XR_TYPE_BODY_JOINTS_LOCATE_INFO_FB) \ + _avail(XrBodyJointLocationsFB, XR_TYPE_BODY_JOINT_LOCATIONS_FB) \ + _avail(XrInteractionProfileDpadBindingEXT, XR_TYPE_INTERACTION_PROFILE_DPAD_BINDING_EXT) \ + _avail(XrInteractionProfileAnalogThresholdVALVE, XR_TYPE_INTERACTION_PROFILE_ANALOG_THRESHOLD_VALVE) \ + _avail(XrHandJointsMotionRangeInfoEXT, XR_TYPE_HAND_JOINTS_MOTION_RANGE_INFO_EXT) \ + _avail(XrSceneObserverCreateInfoMSFT, XR_TYPE_SCENE_OBSERVER_CREATE_INFO_MSFT) \ + _avail(XrSceneCreateInfoMSFT, XR_TYPE_SCENE_CREATE_INFO_MSFT) \ + _avail(XrNewSceneComputeInfoMSFT, XR_TYPE_NEW_SCENE_COMPUTE_INFO_MSFT) \ + _avail(XrVisualMeshComputeLodInfoMSFT, XR_TYPE_VISUAL_MESH_COMPUTE_LOD_INFO_MSFT) \ + _avail(XrSceneComponentsMSFT, XR_TYPE_SCENE_COMPONENTS_MSFT) \ + _avail(XrSceneComponentsGetInfoMSFT, XR_TYPE_SCENE_COMPONENTS_GET_INFO_MSFT) \ + _avail(XrSceneComponentLocationsMSFT, XR_TYPE_SCENE_COMPONENT_LOCATIONS_MSFT) \ + _avail(XrSceneComponentsLocateInfoMSFT, XR_TYPE_SCENE_COMPONENTS_LOCATE_INFO_MSFT) \ + _avail(XrSceneObjectsMSFT, XR_TYPE_SCENE_OBJECTS_MSFT) \ + _avail(XrSceneComponentParentFilterInfoMSFT, XR_TYPE_SCENE_COMPONENT_PARENT_FILTER_INFO_MSFT) \ + _avail(XrSceneObjectTypesFilterInfoMSFT, XR_TYPE_SCENE_OBJECT_TYPES_FILTER_INFO_MSFT) \ + _avail(XrScenePlanesMSFT, XR_TYPE_SCENE_PLANES_MSFT) \ + _avail(XrScenePlaneAlignmentFilterInfoMSFT, XR_TYPE_SCENE_PLANE_ALIGNMENT_FILTER_INFO_MSFT) \ + _avail(XrSceneMeshesMSFT, XR_TYPE_SCENE_MESHES_MSFT) \ + _avail(XrSceneMeshBuffersGetInfoMSFT, XR_TYPE_SCENE_MESH_BUFFERS_GET_INFO_MSFT) \ + _avail(XrSceneMeshBuffersMSFT, XR_TYPE_SCENE_MESH_BUFFERS_MSFT) \ + _avail(XrSceneMeshVertexBufferMSFT, XR_TYPE_SCENE_MESH_VERTEX_BUFFER_MSFT) \ + _avail(XrSceneMeshIndicesUint32MSFT, XR_TYPE_SCENE_MESH_INDICES_UINT32_MSFT) \ + _avail(XrSceneMeshIndicesUint16MSFT, XR_TYPE_SCENE_MESH_INDICES_UINT16_MSFT) \ + _avail(XrSerializedSceneFragmentDataGetInfoMSFT, XR_TYPE_SERIALIZED_SCENE_FRAGMENT_DATA_GET_INFO_MSFT) \ + _avail(XrSceneDeserializeInfoMSFT, XR_TYPE_SCENE_DESERIALIZE_INFO_MSFT) \ + _avail(XrEventDataDisplayRefreshRateChangedFB, XR_TYPE_EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB) \ + _avail(XrViveTrackerPathsHTCX, XR_TYPE_VIVE_TRACKER_PATHS_HTCX) \ + _avail(XrEventDataViveTrackerConnectedHTCX, XR_TYPE_EVENT_DATA_VIVE_TRACKER_CONNECTED_HTCX) \ + _avail(XrSystemFacialTrackingPropertiesHTC, XR_TYPE_SYSTEM_FACIAL_TRACKING_PROPERTIES_HTC) \ + _avail(XrFacialExpressionsHTC, XR_TYPE_FACIAL_EXPRESSIONS_HTC) \ + _avail(XrFacialTrackerCreateInfoHTC, XR_TYPE_FACIAL_TRACKER_CREATE_INFO_HTC) \ + _avail(XrSystemColorSpacePropertiesFB, XR_TYPE_SYSTEM_COLOR_SPACE_PROPERTIES_FB) \ + _avail(XrHandTrackingMeshFB, XR_TYPE_HAND_TRACKING_MESH_FB) \ + _avail(XrHandTrackingScaleFB, XR_TYPE_HAND_TRACKING_SCALE_FB) \ + _avail(XrHandTrackingAimStateFB, XR_TYPE_HAND_TRACKING_AIM_STATE_FB) \ + _avail(XrHandTrackingCapsulesStateFB, XR_TYPE_HAND_TRACKING_CAPSULES_STATE_FB) \ + _avail(XrSystemSpatialEntityPropertiesFB, XR_TYPE_SYSTEM_SPATIAL_ENTITY_PROPERTIES_FB) \ + _avail(XrSpatialAnchorCreateInfoFB, XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_FB) \ + _avail(XrSpaceComponentStatusSetInfoFB, XR_TYPE_SPACE_COMPONENT_STATUS_SET_INFO_FB) \ + _avail(XrSpaceComponentStatusFB, XR_TYPE_SPACE_COMPONENT_STATUS_FB) \ + _avail(XrEventDataSpatialAnchorCreateCompleteFB, XR_TYPE_EVENT_DATA_SPATIAL_ANCHOR_CREATE_COMPLETE_FB) \ + _avail(XrEventDataSpaceSetStatusCompleteFB, XR_TYPE_EVENT_DATA_SPACE_SET_STATUS_COMPLETE_FB) \ + _avail(XrFoveationProfileCreateInfoFB, XR_TYPE_FOVEATION_PROFILE_CREATE_INFO_FB) \ + _avail(XrSwapchainCreateInfoFoveationFB, XR_TYPE_SWAPCHAIN_CREATE_INFO_FOVEATION_FB) \ + _avail(XrSwapchainStateFoveationFB, XR_TYPE_SWAPCHAIN_STATE_FOVEATION_FB) \ + _avail(XrFoveationLevelProfileCreateInfoFB, XR_TYPE_FOVEATION_LEVEL_PROFILE_CREATE_INFO_FB) \ + _avail(XrSystemKeyboardTrackingPropertiesFB, XR_TYPE_SYSTEM_KEYBOARD_TRACKING_PROPERTIES_FB) \ + _avail(XrKeyboardSpaceCreateInfoFB, XR_TYPE_KEYBOARD_SPACE_CREATE_INFO_FB) \ + _avail(XrKeyboardTrackingQueryFB, XR_TYPE_KEYBOARD_TRACKING_QUERY_FB) \ + _avail(XrTriangleMeshCreateInfoFB, XR_TYPE_TRIANGLE_MESH_CREATE_INFO_FB) \ + _avail(XrSystemPassthroughPropertiesFB, XR_TYPE_SYSTEM_PASSTHROUGH_PROPERTIES_FB) \ + _avail(XrSystemPassthroughProperties2FB, XR_TYPE_SYSTEM_PASSTHROUGH_PROPERTIES2_FB) \ + _avail(XrPassthroughCreateInfoFB, XR_TYPE_PASSTHROUGH_CREATE_INFO_FB) \ + _avail(XrPassthroughLayerCreateInfoFB, XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_FB) \ + _avail(XrCompositionLayerPassthroughFB, XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_FB) \ + _avail(XrGeometryInstanceCreateInfoFB, XR_TYPE_GEOMETRY_INSTANCE_CREATE_INFO_FB) \ + _avail(XrGeometryInstanceTransformFB, XR_TYPE_GEOMETRY_INSTANCE_TRANSFORM_FB) \ + _avail(XrPassthroughStyleFB, XR_TYPE_PASSTHROUGH_STYLE_FB) \ + _avail(XrPassthroughColorMapMonoToRgbaFB, XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_RGBA_FB) \ + _avail(XrPassthroughColorMapMonoToMonoFB, XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_MONO_FB) \ + _avail(XrPassthroughBrightnessContrastSaturationFB, XR_TYPE_PASSTHROUGH_BRIGHTNESS_CONTRAST_SATURATION_FB) \ + _avail(XrEventDataPassthroughStateChangedFB, XR_TYPE_EVENT_DATA_PASSTHROUGH_STATE_CHANGED_FB) \ + _avail(XrRenderModelPathInfoFB, XR_TYPE_RENDER_MODEL_PATH_INFO_FB) \ + _avail(XrRenderModelPropertiesFB, XR_TYPE_RENDER_MODEL_PROPERTIES_FB) \ + _avail(XrRenderModelBufferFB, XR_TYPE_RENDER_MODEL_BUFFER_FB) \ + _avail(XrRenderModelLoadInfoFB, XR_TYPE_RENDER_MODEL_LOAD_INFO_FB) \ + _avail(XrSystemRenderModelPropertiesFB, XR_TYPE_SYSTEM_RENDER_MODEL_PROPERTIES_FB) \ + _avail(XrRenderModelCapabilitiesRequestFB, XR_TYPE_RENDER_MODEL_CAPABILITIES_REQUEST_FB) \ + _avail(XrViewLocateFoveatedRenderingVARJO, XR_TYPE_VIEW_LOCATE_FOVEATED_RENDERING_VARJO) \ + _avail(XrFoveatedViewConfigurationViewVARJO, XR_TYPE_FOVEATED_VIEW_CONFIGURATION_VIEW_VARJO) \ + _avail(XrSystemFoveatedRenderingPropertiesVARJO, XR_TYPE_SYSTEM_FOVEATED_RENDERING_PROPERTIES_VARJO) \ + _avail(XrCompositionLayerDepthTestVARJO, XR_TYPE_COMPOSITION_LAYER_DEPTH_TEST_VARJO) \ + _avail(XrSystemMarkerTrackingPropertiesVARJO, XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_VARJO) \ + _avail(XrEventDataMarkerTrackingUpdateVARJO, XR_TYPE_EVENT_DATA_MARKER_TRACKING_UPDATE_VARJO) \ + _avail(XrMarkerSpaceCreateInfoVARJO, XR_TYPE_MARKER_SPACE_CREATE_INFO_VARJO) \ + _avail(XrFrameEndInfoML, XR_TYPE_FRAME_END_INFO_ML) \ + _avail(XrGlobalDimmerFrameEndInfoML, XR_TYPE_GLOBAL_DIMMER_FRAME_END_INFO_ML) \ + _avail(XrSystemMarkerUnderstandingPropertiesML, XR_TYPE_SYSTEM_MARKER_UNDERSTANDING_PROPERTIES_ML) \ + _avail(XrMarkerDetectorCreateInfoML, XR_TYPE_MARKER_DETECTOR_CREATE_INFO_ML) \ + _avail(XrMarkerDetectorArucoInfoML, XR_TYPE_MARKER_DETECTOR_ARUCO_INFO_ML) \ + _avail(XrMarkerDetectorSizeInfoML, XR_TYPE_MARKER_DETECTOR_SIZE_INFO_ML) \ + _avail(XrMarkerDetectorAprilTagInfoML, XR_TYPE_MARKER_DETECTOR_APRIL_TAG_INFO_ML) \ + _avail(XrMarkerDetectorCustomProfileInfoML, XR_TYPE_MARKER_DETECTOR_CUSTOM_PROFILE_INFO_ML) \ + _avail(XrMarkerDetectorSnapshotInfoML, XR_TYPE_MARKER_DETECTOR_SNAPSHOT_INFO_ML) \ + _avail(XrMarkerDetectorStateML, XR_TYPE_MARKER_DETECTOR_STATE_ML) \ + _avail(XrMarkerSpaceCreateInfoML, XR_TYPE_MARKER_SPACE_CREATE_INFO_ML) \ + _avail(XrLocalizationMapML, XR_TYPE_LOCALIZATION_MAP_ML) \ + _avail(XrEventDataLocalizationChangedML, XR_TYPE_EVENT_DATA_LOCALIZATION_CHANGED_ML) \ + _avail(XrMapLocalizationRequestInfoML, XR_TYPE_MAP_LOCALIZATION_REQUEST_INFO_ML) \ + _avail(XrLocalizationMapImportInfoML, XR_TYPE_LOCALIZATION_MAP_IMPORT_INFO_ML) \ + _avail(XrLocalizationEnableEventsInfoML, XR_TYPE_LOCALIZATION_ENABLE_EVENTS_INFO_ML) \ + _avail(XrSpatialAnchorsCreateInfoFromPoseML, XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_POSE_ML) \ + _avail(XrCreateSpatialAnchorsCompletionML, XR_TYPE_CREATE_SPATIAL_ANCHORS_COMPLETION_ML) \ + _avail(XrSpatialAnchorStateML, XR_TYPE_SPATIAL_ANCHOR_STATE_ML) \ + _avail(XrSpatialAnchorsCreateStorageInfoML, XR_TYPE_SPATIAL_ANCHORS_CREATE_STORAGE_INFO_ML) \ + _avail(XrSpatialAnchorsQueryInfoRadiusML, XR_TYPE_SPATIAL_ANCHORS_QUERY_INFO_RADIUS_ML) \ + _avail(XrSpatialAnchorsQueryCompletionML, XR_TYPE_SPATIAL_ANCHORS_QUERY_COMPLETION_ML) \ + _avail(XrSpatialAnchorsCreateInfoFromUuidsML, XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_UUIDS_ML) \ + _avail(XrSpatialAnchorsPublishInfoML, XR_TYPE_SPATIAL_ANCHORS_PUBLISH_INFO_ML) \ + _avail(XrSpatialAnchorsPublishCompletionML, XR_TYPE_SPATIAL_ANCHORS_PUBLISH_COMPLETION_ML) \ + _avail(XrSpatialAnchorsDeleteInfoML, XR_TYPE_SPATIAL_ANCHORS_DELETE_INFO_ML) \ + _avail(XrSpatialAnchorsDeleteCompletionML, XR_TYPE_SPATIAL_ANCHORS_DELETE_COMPLETION_ML) \ + _avail(XrSpatialAnchorsUpdateExpirationInfoML, XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_INFO_ML) \ + _avail(XrSpatialAnchorsUpdateExpirationCompletionML, XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_COMPLETION_ML) \ + _avail(XrSpatialAnchorsPublishCompletionDetailsML, XR_TYPE_SPATIAL_ANCHORS_PUBLISH_COMPLETION_DETAILS_ML) \ + _avail(XrSpatialAnchorsDeleteCompletionDetailsML, XR_TYPE_SPATIAL_ANCHORS_DELETE_COMPLETION_DETAILS_ML) \ + _avail(XrSpatialAnchorsUpdateExpirationCompletionDetailsML, XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_COMPLETION_DETAILS_ML) \ + _avail(XrSpatialAnchorPersistenceInfoMSFT, XR_TYPE_SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT) \ + _avail(XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT, XR_TYPE_SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_INFO_MSFT) \ + _avail(XrSceneMarkersMSFT, XR_TYPE_SCENE_MARKERS_MSFT) \ + _avail(XrSceneMarkerTypeFilterMSFT, XR_TYPE_SCENE_MARKER_TYPE_FILTER_MSFT) \ + _avail(XrSceneMarkerQRCodesMSFT, XR_TYPE_SCENE_MARKER_QR_CODES_MSFT) \ + _avail(XrSpaceQueryInfoFB, XR_TYPE_SPACE_QUERY_INFO_FB) \ + _avail(XrSpaceStorageLocationFilterInfoFB, XR_TYPE_SPACE_STORAGE_LOCATION_FILTER_INFO_FB) \ + _avail(XrSpaceUuidFilterInfoFB, XR_TYPE_SPACE_UUID_FILTER_INFO_FB) \ + _avail(XrSpaceComponentFilterInfoFB, XR_TYPE_SPACE_COMPONENT_FILTER_INFO_FB) \ + _avail(XrSpaceQueryResultsFB, XR_TYPE_SPACE_QUERY_RESULTS_FB) \ + _avail(XrEventDataSpaceQueryResultsAvailableFB, XR_TYPE_EVENT_DATA_SPACE_QUERY_RESULTS_AVAILABLE_FB) \ + _avail(XrEventDataSpaceQueryCompleteFB, XR_TYPE_EVENT_DATA_SPACE_QUERY_COMPLETE_FB) \ + _avail(XrSpaceSaveInfoFB, XR_TYPE_SPACE_SAVE_INFO_FB) \ + _avail(XrSpaceEraseInfoFB, XR_TYPE_SPACE_ERASE_INFO_FB) \ + _avail(XrEventDataSpaceSaveCompleteFB, XR_TYPE_EVENT_DATA_SPACE_SAVE_COMPLETE_FB) \ + _avail(XrEventDataSpaceEraseCompleteFB, XR_TYPE_EVENT_DATA_SPACE_ERASE_COMPLETE_FB) \ + _avail(XrSpaceShareInfoFB, XR_TYPE_SPACE_SHARE_INFO_FB) \ + _avail(XrEventDataSpaceShareCompleteFB, XR_TYPE_EVENT_DATA_SPACE_SHARE_COMPLETE_FB) \ + _avail(XrCompositionLayerSpaceWarpInfoFB, XR_TYPE_COMPOSITION_LAYER_SPACE_WARP_INFO_FB) \ + _avail(XrSystemSpaceWarpPropertiesFB, XR_TYPE_SYSTEM_SPACE_WARP_PROPERTIES_FB) \ + _avail(XrHapticAmplitudeEnvelopeVibrationFB, XR_TYPE_HAPTIC_AMPLITUDE_ENVELOPE_VIBRATION_FB) \ + _avail(XrSemanticLabelsFB, XR_TYPE_SEMANTIC_LABELS_FB) \ + _avail(XrRoomLayoutFB, XR_TYPE_ROOM_LAYOUT_FB) \ + _avail(XrBoundary2DFB, XR_TYPE_BOUNDARY_2D_FB) \ + _avail(XrSemanticLabelsSupportInfoFB, XR_TYPE_SEMANTIC_LABELS_SUPPORT_INFO_FB) \ + _avail(XrDigitalLensControlALMALENCE, XR_TYPE_DIGITAL_LENS_CONTROL_ALMALENCE) \ + _avail(XrEventDataSceneCaptureCompleteFB, XR_TYPE_EVENT_DATA_SCENE_CAPTURE_COMPLETE_FB) \ + _avail(XrSceneCaptureRequestInfoFB, XR_TYPE_SCENE_CAPTURE_REQUEST_INFO_FB) \ + _avail(XrSpaceContainerFB, XR_TYPE_SPACE_CONTAINER_FB) \ + _avail(XrFoveationEyeTrackedProfileCreateInfoMETA, XR_TYPE_FOVEATION_EYE_TRACKED_PROFILE_CREATE_INFO_META) \ + _avail(XrFoveationEyeTrackedStateMETA, XR_TYPE_FOVEATION_EYE_TRACKED_STATE_META) \ + _avail(XrSystemFoveationEyeTrackedPropertiesMETA, XR_TYPE_SYSTEM_FOVEATION_EYE_TRACKED_PROPERTIES_META) \ + _avail(XrSystemFaceTrackingPropertiesFB, XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES_FB) \ + _avail(XrFaceTrackerCreateInfoFB, XR_TYPE_FACE_TRACKER_CREATE_INFO_FB) \ + _avail(XrFaceExpressionInfoFB, XR_TYPE_FACE_EXPRESSION_INFO_FB) \ + _avail(XrFaceExpressionWeightsFB, XR_TYPE_FACE_EXPRESSION_WEIGHTS_FB) \ + _avail(XrEyeTrackerCreateInfoFB, XR_TYPE_EYE_TRACKER_CREATE_INFO_FB) \ + _avail(XrEyeGazesInfoFB, XR_TYPE_EYE_GAZES_INFO_FB) \ + _avail(XrSystemEyeTrackingPropertiesFB, XR_TYPE_SYSTEM_EYE_TRACKING_PROPERTIES_FB) \ + _avail(XrEyeGazesFB, XR_TYPE_EYE_GAZES_FB) \ + _avail(XrPassthroughKeyboardHandsIntensityFB, XR_TYPE_PASSTHROUGH_KEYBOARD_HANDS_INTENSITY_FB) \ + _avail(XrCompositionLayerSettingsFB, XR_TYPE_COMPOSITION_LAYER_SETTINGS_FB) \ + _avail(XrHapticPcmVibrationFB, XR_TYPE_HAPTIC_PCM_VIBRATION_FB) \ + _avail(XrDevicePcmSampleRateStateFB, XR_TYPE_DEVICE_PCM_SAMPLE_RATE_STATE_FB) \ + _avail(XrFrameSynthesisInfoEXT, XR_TYPE_FRAME_SYNTHESIS_INFO_EXT) \ + _avail(XrFrameSynthesisConfigViewEXT, XR_TYPE_FRAME_SYNTHESIS_CONFIG_VIEW_EXT) \ + _avail(XrCompositionLayerDepthTestFB, XR_TYPE_COMPOSITION_LAYER_DEPTH_TEST_FB) \ + _avail(XrLocalDimmingFrameEndInfoMETA, XR_TYPE_LOCAL_DIMMING_FRAME_END_INFO_META) \ + _avail(XrPassthroughPreferencesMETA, XR_TYPE_PASSTHROUGH_PREFERENCES_META) \ + _avail(XrSystemVirtualKeyboardPropertiesMETA, XR_TYPE_SYSTEM_VIRTUAL_KEYBOARD_PROPERTIES_META) \ + _avail(XrVirtualKeyboardCreateInfoMETA, XR_TYPE_VIRTUAL_KEYBOARD_CREATE_INFO_META) \ + _avail(XrVirtualKeyboardSpaceCreateInfoMETA, XR_TYPE_VIRTUAL_KEYBOARD_SPACE_CREATE_INFO_META) \ + _avail(XrVirtualKeyboardLocationInfoMETA, XR_TYPE_VIRTUAL_KEYBOARD_LOCATION_INFO_META) \ + _avail(XrVirtualKeyboardModelVisibilitySetInfoMETA, XR_TYPE_VIRTUAL_KEYBOARD_MODEL_VISIBILITY_SET_INFO_META) \ + _avail(XrVirtualKeyboardAnimationStateMETA, XR_TYPE_VIRTUAL_KEYBOARD_ANIMATION_STATE_META) \ + _avail(XrVirtualKeyboardModelAnimationStatesMETA, XR_TYPE_VIRTUAL_KEYBOARD_MODEL_ANIMATION_STATES_META) \ + _avail(XrVirtualKeyboardTextureDataMETA, XR_TYPE_VIRTUAL_KEYBOARD_TEXTURE_DATA_META) \ + _avail(XrVirtualKeyboardInputInfoMETA, XR_TYPE_VIRTUAL_KEYBOARD_INPUT_INFO_META) \ + _avail(XrVirtualKeyboardTextContextChangeInfoMETA, XR_TYPE_VIRTUAL_KEYBOARD_TEXT_CONTEXT_CHANGE_INFO_META) \ + _avail(XrEventDataVirtualKeyboardCommitTextMETA, XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_COMMIT_TEXT_META) \ + _avail(XrEventDataVirtualKeyboardBackspaceMETA, XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_BACKSPACE_META) \ + _avail(XrEventDataVirtualKeyboardEnterMETA, XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_ENTER_META) \ + _avail(XrEventDataVirtualKeyboardShownMETA, XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_SHOWN_META) \ + _avail(XrEventDataVirtualKeyboardHiddenMETA, XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_HIDDEN_META) \ + _avail(XrExternalCameraOCULUS, XR_TYPE_EXTERNAL_CAMERA_OCULUS) \ + _avail(XrPerformanceMetricsStateMETA, XR_TYPE_PERFORMANCE_METRICS_STATE_META) \ + _avail(XrPerformanceMetricsCounterMETA, XR_TYPE_PERFORMANCE_METRICS_COUNTER_META) \ + _avail(XrSpaceListSaveInfoFB, XR_TYPE_SPACE_LIST_SAVE_INFO_FB) \ + _avail(XrEventDataSpaceListSaveCompleteFB, XR_TYPE_EVENT_DATA_SPACE_LIST_SAVE_COMPLETE_FB) \ + _avail(XrSpaceUserCreateInfoFB, XR_TYPE_SPACE_USER_CREATE_INFO_FB) \ + _avail(XrSystemHeadsetIdPropertiesMETA, XR_TYPE_SYSTEM_HEADSET_ID_PROPERTIES_META) \ + _avail(XrSystemSpaceDiscoveryPropertiesMETA, XR_TYPE_SYSTEM_SPACE_DISCOVERY_PROPERTIES_META) \ + _avail(XrSpaceDiscoveryInfoMETA, XR_TYPE_SPACE_DISCOVERY_INFO_META) \ + _avail(XrSpaceFilterUuidMETA, XR_TYPE_SPACE_FILTER_UUID_META) \ + _avail(XrSpaceFilterComponentMETA, XR_TYPE_SPACE_FILTER_COMPONENT_META) \ + _avail(XrSpaceDiscoveryResultsMETA, XR_TYPE_SPACE_DISCOVERY_RESULTS_META) \ + _avail(XrEventDataSpaceDiscoveryResultsAvailableMETA, XR_TYPE_EVENT_DATA_SPACE_DISCOVERY_RESULTS_AVAILABLE_META) \ + _avail(XrEventDataSpaceDiscoveryCompleteMETA, XR_TYPE_EVENT_DATA_SPACE_DISCOVERY_COMPLETE_META) \ + _avail(XrRecommendedLayerResolutionMETA, XR_TYPE_RECOMMENDED_LAYER_RESOLUTION_META) \ + _avail(XrRecommendedLayerResolutionGetInfoMETA, XR_TYPE_RECOMMENDED_LAYER_RESOLUTION_GET_INFO_META) \ + _avail(XrSystemSpacePersistencePropertiesMETA, XR_TYPE_SYSTEM_SPACE_PERSISTENCE_PROPERTIES_META) \ + _avail(XrSpacesSaveInfoMETA, XR_TYPE_SPACES_SAVE_INFO_META) \ + _avail(XrEventDataSpacesSaveResultMETA, XR_TYPE_EVENT_DATA_SPACES_SAVE_RESULT_META) \ + _avail(XrSpacesEraseInfoMETA, XR_TYPE_SPACES_ERASE_INFO_META) \ + _avail(XrEventDataSpacesEraseResultMETA, XR_TYPE_EVENT_DATA_SPACES_ERASE_RESULT_META) \ + _avail(XrPassthroughColorLutCreateInfoMETA, XR_TYPE_PASSTHROUGH_COLOR_LUT_CREATE_INFO_META) \ + _avail(XrPassthroughColorLutUpdateInfoMETA, XR_TYPE_PASSTHROUGH_COLOR_LUT_UPDATE_INFO_META) \ + _avail(XrPassthroughColorMapLutMETA, XR_TYPE_PASSTHROUGH_COLOR_MAP_LUT_META) \ + _avail(XrPassthroughColorMapInterpolatedLutMETA, XR_TYPE_PASSTHROUGH_COLOR_MAP_INTERPOLATED_LUT_META) \ + _avail(XrSystemPassthroughColorLutPropertiesMETA, XR_TYPE_SYSTEM_PASSTHROUGH_COLOR_LUT_PROPERTIES_META) \ + _avail(XrSpaceTriangleMeshGetInfoMETA, XR_TYPE_SPACE_TRIANGLE_MESH_GET_INFO_META) \ + _avail(XrSpaceTriangleMeshMETA, XR_TYPE_SPACE_TRIANGLE_MESH_META) \ + _avail(XrSystemPropertiesBodyTrackingFullBodyMETA, XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_FULL_BODY_META) \ + _avail(XrEventDataPassthroughLayerResumedMETA, XR_TYPE_EVENT_DATA_PASSTHROUGH_LAYER_RESUMED_META) \ + _avail(XrBodyTrackingCalibrationStatusMETA, XR_TYPE_BODY_TRACKING_CALIBRATION_STATUS_META) \ + _avail(XrBodyTrackingCalibrationInfoMETA, XR_TYPE_BODY_TRACKING_CALIBRATION_INFO_META) \ + _avail(XrSystemPropertiesBodyTrackingCalibrationMETA, XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_CALIBRATION_META) \ + _avail(XrSystemPropertiesBodyTrackingFidelityMETA, XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_FIDELITY_META) \ + _avail(XrBodyTrackingFidelityStatusMETA, XR_TYPE_BODY_TRACKING_FIDELITY_STATUS_META) \ + _avail(XrSystemFaceTrackingProperties2FB, XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES2_FB) \ + _avail(XrFaceTrackerCreateInfo2FB, XR_TYPE_FACE_TRACKER_CREATE_INFO2_FB) \ + _avail(XrFaceExpressionInfo2FB, XR_TYPE_FACE_EXPRESSION_INFO2_FB) \ + _avail(XrFaceExpressionWeights2FB, XR_TYPE_FACE_EXPRESSION_WEIGHTS2_FB) \ + _avail(XrSystemSpatialEntitySharingPropertiesMETA, XR_TYPE_SYSTEM_SPATIAL_ENTITY_SHARING_PROPERTIES_META) \ + _avail(XrShareSpacesInfoMETA, XR_TYPE_SHARE_SPACES_INFO_META) \ + _avail(XrEventDataShareSpacesCompleteMETA, XR_TYPE_EVENT_DATA_SHARE_SPACES_COMPLETE_META) \ + _avail(XrEnvironmentDepthProviderCreateInfoMETA, XR_TYPE_ENVIRONMENT_DEPTH_PROVIDER_CREATE_INFO_META) \ + _avail(XrEnvironmentDepthSwapchainCreateInfoMETA, XR_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_CREATE_INFO_META) \ + _avail(XrEnvironmentDepthSwapchainStateMETA, XR_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_STATE_META) \ + _avail(XrEnvironmentDepthImageAcquireInfoMETA, XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_ACQUIRE_INFO_META) \ + _avail(XrEnvironmentDepthImageViewMETA, XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_VIEW_META) \ + _avail(XrEnvironmentDepthImageMETA, XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_META) \ + _avail(XrEnvironmentDepthImageTimestampMETA, XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_TIMESTAMP_META) \ + _avail(XrEnvironmentDepthHandRemovalSetInfoMETA, XR_TYPE_ENVIRONMENT_DEPTH_HAND_REMOVAL_SET_INFO_META) \ + _avail(XrSystemEnvironmentDepthPropertiesMETA, XR_TYPE_SYSTEM_ENVIRONMENT_DEPTH_PROPERTIES_META) \ + _avail(XrRenderModelCreateInfoEXT, XR_TYPE_RENDER_MODEL_CREATE_INFO_EXT) \ + _avail(XrRenderModelPropertiesGetInfoEXT, XR_TYPE_RENDER_MODEL_PROPERTIES_GET_INFO_EXT) \ + _avail(XrRenderModelPropertiesEXT, XR_TYPE_RENDER_MODEL_PROPERTIES_EXT) \ + _avail(XrRenderModelSpaceCreateInfoEXT, XR_TYPE_RENDER_MODEL_SPACE_CREATE_INFO_EXT) \ + _avail(XrRenderModelStateGetInfoEXT, XR_TYPE_RENDER_MODEL_STATE_GET_INFO_EXT) \ + _avail(XrRenderModelStateEXT, XR_TYPE_RENDER_MODEL_STATE_EXT) \ + _avail(XrRenderModelAssetCreateInfoEXT, XR_TYPE_RENDER_MODEL_ASSET_CREATE_INFO_EXT) \ + _avail(XrRenderModelAssetDataGetInfoEXT, XR_TYPE_RENDER_MODEL_ASSET_DATA_GET_INFO_EXT) \ + _avail(XrRenderModelAssetDataEXT, XR_TYPE_RENDER_MODEL_ASSET_DATA_EXT) \ + _avail(XrRenderModelAssetPropertiesGetInfoEXT, XR_TYPE_RENDER_MODEL_ASSET_PROPERTIES_GET_INFO_EXT) \ + _avail(XrRenderModelAssetPropertiesEXT, XR_TYPE_RENDER_MODEL_ASSET_PROPERTIES_EXT) \ + _avail(XrInteractionRenderModelIdsEnumerateInfoEXT, XR_TYPE_INTERACTION_RENDER_MODEL_IDS_ENUMERATE_INFO_EXT) \ + _avail(XrInteractionRenderModelSubactionPathInfoEXT, XR_TYPE_INTERACTION_RENDER_MODEL_SUBACTION_PATH_INFO_EXT) \ + _avail(XrInteractionRenderModelTopLevelUserPathGetInfoEXT, XR_TYPE_INTERACTION_RENDER_MODEL_TOP_LEVEL_USER_PATH_GET_INFO_EXT) \ + _avail(XrEventDataInteractionRenderModelsChangedEXT, XR_TYPE_EVENT_DATA_INTERACTION_RENDER_MODELS_CHANGED_EXT) \ + _avail(XrPassthroughCreateInfoHTC, XR_TYPE_PASSTHROUGH_CREATE_INFO_HTC) \ + _avail(XrPassthroughColorHTC, XR_TYPE_PASSTHROUGH_COLOR_HTC) \ + _avail(XrPassthroughMeshTransformInfoHTC, XR_TYPE_PASSTHROUGH_MESH_TRANSFORM_INFO_HTC) \ + _avail(XrCompositionLayerPassthroughHTC, XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_HTC) \ + _avail(XrFoveationApplyInfoHTC, XR_TYPE_FOVEATION_APPLY_INFO_HTC) \ + _avail(XrFoveationDynamicModeInfoHTC, XR_TYPE_FOVEATION_DYNAMIC_MODE_INFO_HTC) \ + _avail(XrFoveationCustomModeInfoHTC, XR_TYPE_FOVEATION_CUSTOM_MODE_INFO_HTC) \ + _avail(XrSystemAnchorPropertiesHTC, XR_TYPE_SYSTEM_ANCHOR_PROPERTIES_HTC) \ + _avail(XrSpatialAnchorCreateInfoHTC, XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_HTC) \ + _avail(XrSystemBodyTrackingPropertiesHTC, XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_HTC) \ + _avail(XrBodyTrackerCreateInfoHTC, XR_TYPE_BODY_TRACKER_CREATE_INFO_HTC) \ + _avail(XrBodyJointsLocateInfoHTC, XR_TYPE_BODY_JOINTS_LOCATE_INFO_HTC) \ + _avail(XrBodyJointLocationsHTC, XR_TYPE_BODY_JOINT_LOCATIONS_HTC) \ + _avail(XrBodySkeletonHTC, XR_TYPE_BODY_SKELETON_HTC) \ + _avail(XrActiveActionSetPrioritiesEXT, XR_TYPE_ACTIVE_ACTION_SET_PRIORITIES_EXT) \ + _avail(XrSystemForceFeedbackCurlPropertiesMNDX, XR_TYPE_SYSTEM_FORCE_FEEDBACK_CURL_PROPERTIES_MNDX) \ + _avail(XrForceFeedbackCurlApplyLocationsMNDX, XR_TYPE_FORCE_FEEDBACK_CURL_APPLY_LOCATIONS_MNDX) \ + _avail(XrSystemBodyTrackingPropertiesBD, XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_BD) \ + _avail(XrBodyTrackerCreateInfoBD, XR_TYPE_BODY_TRACKER_CREATE_INFO_BD) \ + _avail(XrBodyJointsLocateInfoBD, XR_TYPE_BODY_JOINTS_LOCATE_INFO_BD) \ + _avail(XrBodyJointLocationsBD, XR_TYPE_BODY_JOINT_LOCATIONS_BD) \ + _avail(XrSystemFacialSimulationPropertiesBD, XR_TYPE_SYSTEM_FACIAL_SIMULATION_PROPERTIES_BD) \ + _avail(XrFaceTrackerCreateInfoBD, XR_TYPE_FACE_TRACKER_CREATE_INFO_BD) \ + _avail(XrFacialSimulationDataGetInfoBD, XR_TYPE_FACIAL_SIMULATION_DATA_GET_INFO_BD) \ + _avail(XrFacialSimulationDataBD, XR_TYPE_FACIAL_SIMULATION_DATA_BD) \ + _avail(XrLipExpressionDataBD, XR_TYPE_LIP_EXPRESSION_DATA_BD) \ + _avail(XrSystemSpatialSensingPropertiesBD, XR_TYPE_SYSTEM_SPATIAL_SENSING_PROPERTIES_BD) \ + _avail(XrSpatialEntityComponentGetInfoBD, XR_TYPE_SPATIAL_ENTITY_COMPONENT_GET_INFO_BD) \ + _avail(XrSpatialEntityLocationGetInfoBD, XR_TYPE_SPATIAL_ENTITY_LOCATION_GET_INFO_BD) \ + _avail(XrSpatialEntityComponentDataLocationBD, XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_LOCATION_BD) \ + _avail(XrSpatialEntityComponentDataSemanticBD, XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_SEMANTIC_BD) \ + _avail(XrSpatialEntityComponentDataBoundingBox2DBD, XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_BOUNDING_BOX_2D_BD) \ + _avail(XrSpatialEntityComponentDataPolygonBD, XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_POLYGON_BD) \ + _avail(XrSpatialEntityComponentDataBoundingBox3DBD, XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_BOUNDING_BOX_3D_BD) \ + _avail(XrSpatialEntityComponentDataTriangleMeshBD, XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_TRIANGLE_MESH_BD) \ + _avail(XrSpatialEntityComponentDataSphereBD, XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_SPHERE_BD) \ + _avail(XrSenseDataProviderCreateInfoBD, XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_BD) \ + _avail(XrSenseDataProviderStartInfoBD, XR_TYPE_SENSE_DATA_PROVIDER_START_INFO_BD) \ + _avail(XrEventDataSenseDataProviderStateChangedBD, XR_TYPE_EVENT_DATA_SENSE_DATA_PROVIDER_STATE_CHANGED_BD) \ + _avail(XrEventDataSenseDataUpdatedBD, XR_TYPE_EVENT_DATA_SENSE_DATA_UPDATED_BD) \ + _avail(XrSenseDataQueryInfoBD, XR_TYPE_SENSE_DATA_QUERY_INFO_BD) \ + _avail(XrSenseDataQueryCompletionBD, XR_TYPE_SENSE_DATA_QUERY_COMPLETION_BD) \ + _avail(XrQueriedSenseDataGetInfoBD, XR_TYPE_QUERIED_SENSE_DATA_GET_INFO_BD) \ + _avail(XrSpatialEntityStateBD, XR_TYPE_SPATIAL_ENTITY_STATE_BD) \ + _avail(XrQueriedSenseDataBD, XR_TYPE_QUERIED_SENSE_DATA_BD) \ + _avail(XrSenseDataFilterUuidBD, XR_TYPE_SENSE_DATA_FILTER_UUID_BD) \ + _avail(XrSenseDataFilterSemanticBD, XR_TYPE_SENSE_DATA_FILTER_SEMANTIC_BD) \ + _avail(XrSpatialEntityAnchorCreateInfoBD, XR_TYPE_SPATIAL_ENTITY_ANCHOR_CREATE_INFO_BD) \ + _avail(XrAnchorSpaceCreateInfoBD, XR_TYPE_ANCHOR_SPACE_CREATE_INFO_BD) \ + _avail(XrFutureCompletionEXT, XR_TYPE_FUTURE_COMPLETION_EXT) \ + _avail(XrSystemSpatialAnchorPropertiesBD, XR_TYPE_SYSTEM_SPATIAL_ANCHOR_PROPERTIES_BD) \ + _avail(XrSpatialAnchorCreateInfoBD, XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_BD) \ + _avail(XrSpatialAnchorCreateCompletionBD, XR_TYPE_SPATIAL_ANCHOR_CREATE_COMPLETION_BD) \ + _avail(XrSpatialAnchorPersistInfoBD, XR_TYPE_SPATIAL_ANCHOR_PERSIST_INFO_BD) \ + _avail(XrSpatialAnchorUnpersistInfoBD, XR_TYPE_SPATIAL_ANCHOR_UNPERSIST_INFO_BD) \ + _avail(XrSystemSpatialAnchorSharingPropertiesBD, XR_TYPE_SYSTEM_SPATIAL_ANCHOR_SHARING_PROPERTIES_BD) \ + _avail(XrSpatialAnchorShareInfoBD, XR_TYPE_SPATIAL_ANCHOR_SHARE_INFO_BD) \ + _avail(XrSharedSpatialAnchorDownloadInfoBD, XR_TYPE_SHARED_SPATIAL_ANCHOR_DOWNLOAD_INFO_BD) \ + _avail(XrSystemSpatialScenePropertiesBD, XR_TYPE_SYSTEM_SPATIAL_SCENE_PROPERTIES_BD) \ + _avail(XrSceneCaptureInfoBD, XR_TYPE_SCENE_CAPTURE_INFO_BD) \ + _avail(XrSystemSpatialMeshPropertiesBD, XR_TYPE_SYSTEM_SPATIAL_MESH_PROPERTIES_BD) \ + _avail(XrSenseDataProviderCreateInfoSpatialMeshBD, XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_SPATIAL_MESH_BD) \ + _avail(XrFuturePollResultProgressBD, XR_TYPE_FUTURE_POLL_RESULT_PROGRESS_BD) \ + _avail(XrBodyTrackingPostureDataBD, XR_TYPE_BODY_TRACKING_POSTURE_DATA_BD) \ + _avail(XrBodyJointVelocitiesBD, XR_TYPE_BODY_JOINT_VELOCITIES_BD) \ + _avail(XrBodyJointAccelerationsBD, XR_TYPE_BODY_JOINT_ACCELERATIONS_BD) \ + _avail(XrBodyTrackingStateBD, XR_TYPE_BODY_TRACKING_STATE_BD) \ + _avail(XrSystemSpatialPlanePropertiesBD, XR_TYPE_SYSTEM_SPATIAL_PLANE_PROPERTIES_BD) \ + _avail(XrSpatialEntityComponentDataPlaneOrientationBD, XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_PLANE_ORIENTATION_BD) \ + _avail(XrSenseDataFilterPlaneOrientationBD, XR_TYPE_SENSE_DATA_FILTER_PLANE_ORIENTATION_BD) \ + _avail(XrSystemLightEstimationPropertiesBD, XR_TYPE_SYSTEM_LIGHT_ESTIMATION_PROPERTIES_BD) \ + _avail(XrSenseDataProviderCreateInfoLightEstimationBD, XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_LIGHT_ESTIMATION_BD) \ + _avail(XrEnvironmentTextureCreateConfigInfoBD, XR_TYPE_ENVIRONMENT_TEXTURE_CREATE_CONFIG_INFO_BD) \ + _avail(XrLightEstimationDataEnvironmentTextureRawBD, XR_TYPE_LIGHT_ESTIMATION_DATA_ENVIRONMENT_TEXTURE_RAW_BD) \ + _avail(XrLightEstimationDataSphericalHarmonicsBD, XR_TYPE_LIGHT_ESTIMATION_DATA_SPHERICAL_HARMONICS_BD) \ + _avail(XrSpatialEntityComponentDataLightEstimationBD, XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_LIGHT_ESTIMATION_BD) \ + _avail(XrSpatialAudioRendererCreateInfoBD, XR_TYPE_SPATIAL_AUDIO_RENDERER_CREATE_INFO_BD) \ + _avail(XrAudioBufferBD, XR_TYPE_AUDIO_BUFFER_BD) \ + _avail(XrSoundObjectDirectivityCardioidBD, XR_TYPE_SOUND_OBJECT_DIRECTIVITY_CARDIOID_BD) \ + _avail(XrSoundObjectShapeSphereBD, XR_TYPE_SOUND_OBJECT_SHAPE_SPHERE_BD) \ + _avail(XrSoundObjectDistanceAttenuationCurveBD, XR_TYPE_SOUND_OBJECT_DISTANCE_ATTENUATION_CURVE_BD) \ + _avail(XrSoundObjectDistanceAttenuationBD, XR_TYPE_SOUND_OBJECT_DISTANCE_ATTENUATION_BD) \ + _avail(XrSoundObjectConfigBD, XR_TYPE_SOUND_OBJECT_CONFIG_BD) \ + _avail(XrSoundFieldConfigBD, XR_TYPE_SOUND_FIELD_CONFIG_BD) \ + _avail(XrSoundFieldChannelDefinitionSurroundBD, XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_SURROUND_BD) \ + _avail(XrSoundFieldChannelDefinitionAmbixBD, XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_AMBIX_BD) \ + _avail(XrSoundFieldChannelDefinitionFumaBD, XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_FUMA_BD) \ + _avail(XrSoundTriangleMeshBD, XR_TYPE_SOUND_TRIANGLE_MESH_BD) \ + _avail(XrSoundObstacleConfigBD, XR_TYPE_SOUND_OBSTACLE_CONFIG_BD) \ + _avail(XrSoundObstacleMaterialConfigBD, XR_TYPE_SOUND_OBSTACLE_MATERIAL_CONFIG_BD) \ + _avail(XrHandTrackingDataSourceInfoEXT, XR_TYPE_HAND_TRACKING_DATA_SOURCE_INFO_EXT) \ + _avail(XrHandTrackingDataSourceStateEXT, XR_TYPE_HAND_TRACKING_DATA_SOURCE_STATE_EXT) \ + _avail(XrSystemPlaneDetectionPropertiesEXT, XR_TYPE_SYSTEM_PLANE_DETECTION_PROPERTIES_EXT) \ + _avail(XrPlaneDetectorCreateInfoEXT, XR_TYPE_PLANE_DETECTOR_CREATE_INFO_EXT) \ + _avail(XrPlaneDetectorBeginInfoEXT, XR_TYPE_PLANE_DETECTOR_BEGIN_INFO_EXT) \ + _avail(XrPlaneDetectorGetInfoEXT, XR_TYPE_PLANE_DETECTOR_GET_INFO_EXT) \ + _avail(XrPlaneDetectorLocationEXT, XR_TYPE_PLANE_DETECTOR_LOCATION_EXT) \ + _avail(XrPlaneDetectorLocationsEXT, XR_TYPE_PLANE_DETECTOR_LOCATIONS_EXT) \ + _avail(XrPlaneDetectorPolygonBufferEXT, XR_TYPE_PLANE_DETECTOR_POLYGON_BUFFER_EXT) \ + _avail(XrTrackableTrackerCreateInfoANDROID, XR_TYPE_TRACKABLE_TRACKER_CREATE_INFO_ANDROID) \ + _avail(XrTrackableGetInfoANDROID, XR_TYPE_TRACKABLE_GET_INFO_ANDROID) \ + _avail(XrTrackablePlaneANDROID, XR_TYPE_TRACKABLE_PLANE_ANDROID) \ + _avail(XrAnchorSpaceCreateInfoANDROID, XR_TYPE_ANCHOR_SPACE_CREATE_INFO_ANDROID) \ + _avail(XrSystemTrackablesPropertiesANDROID, XR_TYPE_SYSTEM_TRACKABLES_PROPERTIES_ANDROID) \ + _avail(XrSystemEyeTrackingPropertiesANDROID, XR_TYPE_SYSTEM_EYE_TRACKING_PROPERTIES_ANDROID) \ + _avail(XrEyesANDROID, XR_TYPE_EYES_ANDROID) \ + _avail(XrEyesGetInfoANDROID, XR_TYPE_EYES_GET_INFO_ANDROID) \ + _avail(XrEyeTrackerCreateInfoANDROID, XR_TYPE_EYE_TRACKER_CREATE_INFO_ANDROID) \ + _avail(XrDeviceAnchorPersistenceCreateInfoANDROID, XR_TYPE_DEVICE_ANCHOR_PERSISTENCE_CREATE_INFO_ANDROID) \ + _avail(XrPersistedAnchorSpaceCreateInfoANDROID, XR_TYPE_PERSISTED_ANCHOR_SPACE_CREATE_INFO_ANDROID) \ + _avail(XrPersistedAnchorSpaceInfoANDROID, XR_TYPE_PERSISTED_ANCHOR_SPACE_INFO_ANDROID) \ + _avail(XrSystemDeviceAnchorPersistencePropertiesANDROID, XR_TYPE_SYSTEM_DEVICE_ANCHOR_PERSISTENCE_PROPERTIES_ANDROID) \ + _avail(XrFaceTrackerCreateInfoANDROID, XR_TYPE_FACE_TRACKER_CREATE_INFO_ANDROID) \ + _avail(XrFaceStateGetInfoANDROID, XR_TYPE_FACE_STATE_GET_INFO_ANDROID) \ + _avail(XrFaceStateANDROID, XR_TYPE_FACE_STATE_ANDROID) \ + _avail(XrSystemFaceTrackingPropertiesANDROID, XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES_ANDROID) \ + _avail(XrSystemPassthroughCameraStatePropertiesANDROID, XR_TYPE_SYSTEM_PASSTHROUGH_CAMERA_STATE_PROPERTIES_ANDROID) \ + _avail(XrPassthroughCameraStateGetInfoANDROID, XR_TYPE_PASSTHROUGH_CAMERA_STATE_GET_INFO_ANDROID) \ + _avail(XrEventDataRecommendedResolutionChangedANDROID, XR_TYPE_EVENT_DATA_RECOMMENDED_RESOLUTION_CHANGED_ANDROID) \ + _avail(XrPassthroughLayerCreateInfoANDROID, XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_ANDROID) \ + _avail(XrPassthroughLayerMeshANDROID, XR_TYPE_PASSTHROUGH_LAYER_MESH_ANDROID) \ + _avail(XrCompositionLayerPassthroughANDROID, XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_ANDROID) \ + _avail(XrSystemPassthroughLayerPropertiesANDROID, XR_TYPE_SYSTEM_PASSTHROUGH_LAYER_PROPERTIES_ANDROID) \ + _avail(XrRaycastInfoANDROID, XR_TYPE_RAYCAST_INFO_ANDROID) \ + _avail(XrRaycastHitResultsANDROID, XR_TYPE_RAYCAST_HIT_RESULTS_ANDROID) \ + _avail(XrPerformanceMetricsStateANDROID, XR_TYPE_PERFORMANCE_METRICS_STATE_ANDROID) \ + _avail(XrPerformanceMetricsCounterANDROID, XR_TYPE_PERFORMANCE_METRICS_COUNTER_ANDROID) \ + _avail(XrTrackableObjectANDROID, XR_TYPE_TRACKABLE_OBJECT_ANDROID) \ + _avail(XrTrackableObjectConfigurationANDROID, XR_TYPE_TRACKABLE_OBJECT_CONFIGURATION_ANDROID) \ + _avail(XrFutureCancelInfoEXT, XR_TYPE_FUTURE_CANCEL_INFO_EXT) \ + _avail(XrFuturePollInfoEXT, XR_TYPE_FUTURE_POLL_INFO_EXT) \ + _avail(XrFuturePollResultEXT, XR_TYPE_FUTURE_POLL_RESULT_EXT) \ + _avail(XrEventDataUserPresenceChangedEXT, XR_TYPE_EVENT_DATA_USER_PRESENCE_CHANGED_EXT) \ + _avail(XrSystemUserPresencePropertiesEXT, XR_TYPE_SYSTEM_USER_PRESENCE_PROPERTIES_EXT) \ + _avail(XrEventDataHeadsetFitChangedML, XR_TYPE_EVENT_DATA_HEADSET_FIT_CHANGED_ML) \ + _avail(XrEventDataEyeCalibrationChangedML, XR_TYPE_EVENT_DATA_EYE_CALIBRATION_CHANGED_ML) \ + _avail(XrUserCalibrationEnableEventsInfoML, XR_TYPE_USER_CALIBRATION_ENABLE_EVENTS_INFO_ML) \ + _avail(XrSystemNotificationsSetInfoML, XR_TYPE_SYSTEM_NOTIFICATIONS_SET_INFO_ML) \ + _avail(XrWorldMeshDetectorCreateInfoML, XR_TYPE_WORLD_MESH_DETECTOR_CREATE_INFO_ML) \ + _avail(XrWorldMeshBlockStateML, XR_TYPE_WORLD_MESH_BLOCK_STATE_ML) \ + _avail(XrWorldMeshStateRequestInfoML, XR_TYPE_WORLD_MESH_STATE_REQUEST_INFO_ML) \ + _avail(XrWorldMeshStateRequestCompletionML, XR_TYPE_WORLD_MESH_STATE_REQUEST_COMPLETION_ML) \ + _avail(XrWorldMeshBufferRecommendedSizeInfoML, XR_TYPE_WORLD_MESH_BUFFER_RECOMMENDED_SIZE_INFO_ML) \ + _avail(XrWorldMeshBufferSizeML, XR_TYPE_WORLD_MESH_BUFFER_SIZE_ML) \ + _avail(XrWorldMeshBufferML, XR_TYPE_WORLD_MESH_BUFFER_ML) \ + _avail(XrWorldMeshBlockRequestML, XR_TYPE_WORLD_MESH_BLOCK_REQUEST_ML) \ + _avail(XrWorldMeshGetInfoML, XR_TYPE_WORLD_MESH_GET_INFO_ML) \ + _avail(XrWorldMeshBlockML, XR_TYPE_WORLD_MESH_BLOCK_ML) \ + _avail(XrWorldMeshRequestCompletionInfoML, XR_TYPE_WORLD_MESH_REQUEST_COMPLETION_INFO_ML) \ + _avail(XrWorldMeshRequestCompletionML, XR_TYPE_WORLD_MESH_REQUEST_COMPLETION_ML) \ + _avail(XrSystemFacialExpressionPropertiesML, XR_TYPE_SYSTEM_FACIAL_EXPRESSION_PROPERTIES_ML) \ + _avail(XrFacialExpressionClientCreateInfoML, XR_TYPE_FACIAL_EXPRESSION_CLIENT_CREATE_INFO_ML) \ + _avail(XrFacialExpressionBlendShapeGetInfoML, XR_TYPE_FACIAL_EXPRESSION_BLEND_SHAPE_GET_INFO_ML) \ + _avail(XrFacialExpressionBlendShapePropertiesML, XR_TYPE_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_ML) \ + _avail(XrSystemBoundaryVisibilityPropertiesMETA, XR_TYPE_SYSTEM_BOUNDARY_VISIBILITY_PROPERTIES_META) \ + _avail(XrEventDataBoundaryVisibilityChangedMETA, XR_TYPE_EVENT_DATA_BOUNDARY_VISIBILITY_CHANGED_META) \ + _avail(XrSystemSimultaneousHandsAndControllersPropertiesMETA, XR_TYPE_SYSTEM_SIMULTANEOUS_HANDS_AND_CONTROLLERS_PROPERTIES_META) \ + _avail(XrSimultaneousHandsAndControllersTrackingResumeInfoMETA, XR_TYPE_SIMULTANEOUS_HANDS_AND_CONTROLLERS_TRACKING_RESUME_INFO_META) \ + _avail(XrSimultaneousHandsAndControllersTrackingPauseInfoMETA, XR_TYPE_SIMULTANEOUS_HANDS_AND_CONTROLLERS_TRACKING_PAUSE_INFO_META) \ + _avail(XrFaceTrackingVisemesMETA, XR_TYPE_FACE_TRACKING_VISEMES_META) \ + _avail(XrSystemFaceTrackingVisemesPropertiesMETA, XR_TYPE_SYSTEM_FACE_TRACKING_VISEMES_PROPERTIES_META) \ + _avail(XrRoomMeshFaceIndicesMETA, XR_TYPE_ROOM_MESH_FACE_INDICES_META) \ + _avail(XrSpaceRoomMeshGetInfoMETA, XR_TYPE_SPACE_ROOM_MESH_GET_INFO_META) \ + _avail(XrRoomMeshMETA, XR_TYPE_ROOM_MESH_META) \ + _avail(XrColocationDiscoveryStartInfoMETA, XR_TYPE_COLOCATION_DISCOVERY_START_INFO_META) \ + _avail(XrColocationDiscoveryStopInfoMETA, XR_TYPE_COLOCATION_DISCOVERY_STOP_INFO_META) \ + _avail(XrColocationAdvertisementStartInfoMETA, XR_TYPE_COLOCATION_ADVERTISEMENT_START_INFO_META) \ + _avail(XrColocationAdvertisementStopInfoMETA, XR_TYPE_COLOCATION_ADVERTISEMENT_STOP_INFO_META) \ + _avail(XrEventDataStartColocationAdvertisementCompleteMETA, XR_TYPE_EVENT_DATA_START_COLOCATION_ADVERTISEMENT_COMPLETE_META) \ + _avail(XrEventDataStopColocationAdvertisementCompleteMETA, XR_TYPE_EVENT_DATA_STOP_COLOCATION_ADVERTISEMENT_COMPLETE_META) \ + _avail(XrEventDataColocationAdvertisementCompleteMETA, XR_TYPE_EVENT_DATA_COLOCATION_ADVERTISEMENT_COMPLETE_META) \ + _avail(XrEventDataStartColocationDiscoveryCompleteMETA, XR_TYPE_EVENT_DATA_START_COLOCATION_DISCOVERY_COMPLETE_META) \ + _avail(XrEventDataColocationDiscoveryResultMETA, XR_TYPE_EVENT_DATA_COLOCATION_DISCOVERY_RESULT_META) \ + _avail(XrEventDataColocationDiscoveryCompleteMETA, XR_TYPE_EVENT_DATA_COLOCATION_DISCOVERY_COMPLETE_META) \ + _avail(XrEventDataStopColocationDiscoveryCompleteMETA, XR_TYPE_EVENT_DATA_STOP_COLOCATION_DISCOVERY_COMPLETE_META) \ + _avail(XrSystemColocationDiscoveryPropertiesMETA, XR_TYPE_SYSTEM_COLOCATION_DISCOVERY_PROPERTIES_META) \ + _avail(XrSystemSpatialEntityGroupSharingPropertiesMETA, XR_TYPE_SYSTEM_SPATIAL_ENTITY_GROUP_SHARING_PROPERTIES_META) \ + _avail(XrShareSpacesRecipientGroupsMETA, XR_TYPE_SHARE_SPACES_RECIPIENT_GROUPS_META) \ + _avail(XrSpaceGroupUuidFilterInfoMETA, XR_TYPE_SPACE_GROUP_UUID_FILTER_INFO_META) \ + _avail(XrSystemEnvironmentRaycastPropertiesMETA, XR_TYPE_SYSTEM_ENVIRONMENT_RAYCAST_PROPERTIES_META) \ + _avail(XrEnvironmentRaycasterCreateInfoMETA, XR_TYPE_ENVIRONMENT_RAYCASTER_CREATE_INFO_META) \ + _avail(XrEnvironmentRaycasterCreateCompletionMETA, XR_TYPE_ENVIRONMENT_RAYCASTER_CREATE_COMPLETION_META) \ + _avail(XrEnvironmentRaycastHitGetInfoMETA, XR_TYPE_ENVIRONMENT_RAYCAST_HIT_GET_INFO_META) \ + _avail(XrEnvironmentRaycastHitMETA, XR_TYPE_ENVIRONMENT_RAYCAST_HIT_META) \ + _avail(XrEnvironmentRaycastFilterDistanceMETA, XR_TYPE_ENVIRONMENT_RAYCAST_FILTER_DISTANCE_META) \ + _avail(XrTilePropertiesMETA, XR_TYPE_TILE_PROPERTIES_META) \ + _avail(XrTilePropertiesHintMETA, XR_TYPE_TILE_PROPERTIES_HINT_META) \ + _avail(XrHandTrackingUnextrapolatedPosesRequestMETA, XR_TYPE_HAND_TRACKING_UNEXTRAPOLATED_POSES_REQUEST_META) \ + _avail(XrHandTrackingUnextrapolatedPosesMETA, XR_TYPE_HAND_TRACKING_UNEXTRAPOLATED_POSES_META) \ + _avail(XrSystemLightEstimationPropertiesANDROID, XR_TYPE_SYSTEM_LIGHT_ESTIMATION_PROPERTIES_ANDROID) \ + _avail(XrLightEstimatorCreateInfoANDROID, XR_TYPE_LIGHT_ESTIMATOR_CREATE_INFO_ANDROID) \ + _avail(XrLightEstimateGetInfoANDROID, XR_TYPE_LIGHT_ESTIMATE_GET_INFO_ANDROID) \ + _avail(XrLightEstimateANDROID, XR_TYPE_LIGHT_ESTIMATE_ANDROID) \ + _avail(XrDirectionalLightANDROID, XR_TYPE_DIRECTIONAL_LIGHT_ANDROID) \ + _avail(XrAmbientLightANDROID, XR_TYPE_AMBIENT_LIGHT_ANDROID) \ + _avail(XrSphericalHarmonicsANDROID, XR_TYPE_SPHERICAL_HARMONICS_ANDROID) \ + _avail(XrSystemMarkerTrackingPropertiesANDROID, XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_ANDROID) \ + _avail(XrTrackableMarkerConfigurationANDROID, XR_TYPE_TRACKABLE_MARKER_CONFIGURATION_ANDROID) \ + _avail(XrTrackableMarkerANDROID, XR_TYPE_TRACKABLE_MARKER_ANDROID) \ + _avail(XrSystemQrCodeTrackingPropertiesANDROID, XR_TYPE_SYSTEM_QR_CODE_TRACKING_PROPERTIES_ANDROID) \ + _avail(XrTrackableQrCodeConfigurationANDROID, XR_TYPE_TRACKABLE_QR_CODE_CONFIGURATION_ANDROID) \ + _avail(XrTrackableQrCodeANDROID, XR_TYPE_TRACKABLE_QR_CODE_ANDROID) \ + _avail(XrSystemImageTrackingPropertiesANDROID, XR_TYPE_SYSTEM_IMAGE_TRACKING_PROPERTIES_ANDROID) \ + _avail(XrTrackableImageDatabaseEntryANDROID, XR_TYPE_TRACKABLE_IMAGE_DATABASE_ENTRY_ANDROID) \ + _avail(XrTrackableImageDatabaseCreateInfoANDROID, XR_TYPE_TRACKABLE_IMAGE_DATABASE_CREATE_INFO_ANDROID) \ + _avail(XrCreateTrackableImageDatabaseCompletionANDROID, XR_TYPE_CREATE_TRACKABLE_IMAGE_DATABASE_COMPLETION_ANDROID) \ + _avail(XrTrackableImageConfigurationANDROID, XR_TYPE_TRACKABLE_IMAGE_CONFIGURATION_ANDROID) \ + _avail(XrTrackableImageANDROID, XR_TYPE_TRACKABLE_IMAGE_ANDROID) \ + _avail(XrEventDataImageTrackingLostANDROID, XR_TYPE_EVENT_DATA_IMAGE_TRACKING_LOST_ANDROID) \ + _avail(XrSystemSceneMeshingPropertiesANDROID, XR_TYPE_SYSTEM_SCENE_MESHING_PROPERTIES_ANDROID) \ + _avail(XrSceneMeshingTrackerCreateInfoANDROID, XR_TYPE_SCENE_MESHING_TRACKER_CREATE_INFO_ANDROID) \ + _avail(XrSceneMeshSnapshotCreateInfoANDROID, XR_TYPE_SCENE_MESH_SNAPSHOT_CREATE_INFO_ANDROID) \ + _avail(XrSceneMeshSnapshotCreationResultANDROID, XR_TYPE_SCENE_MESH_SNAPSHOT_CREATION_RESULT_ANDROID) \ + _avail(XrSceneSubmeshStateANDROID, XR_TYPE_SCENE_SUBMESH_STATE_ANDROID) \ + _avail(XrSceneSubmeshDataANDROID, XR_TYPE_SCENE_SUBMESH_DATA_ANDROID) \ + _avail(XrSpatialCapabilityComponentTypesEXT, XR_TYPE_SPATIAL_CAPABILITY_COMPONENT_TYPES_EXT) \ + _avail(XrSpatialContextCreateInfoEXT, XR_TYPE_SPATIAL_CONTEXT_CREATE_INFO_EXT) \ + _avail(XrCreateSpatialContextCompletionEXT, XR_TYPE_CREATE_SPATIAL_CONTEXT_COMPLETION_EXT) \ + _avail(XrSpatialDiscoverySnapshotCreateInfoEXT, XR_TYPE_SPATIAL_DISCOVERY_SNAPSHOT_CREATE_INFO_EXT) \ + _avail(XrCreateSpatialDiscoverySnapshotCompletionInfoEXT, XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_INFO_EXT) \ + _avail(XrCreateSpatialDiscoverySnapshotCompletionEXT, XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_EXT) \ + _avail(XrSpatialComponentDataQueryConditionEXT, XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_CONDITION_EXT) \ + _avail(XrSpatialComponentDataQueryResultEXT, XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_RESULT_EXT) \ + _avail(XrSpatialBufferGetInfoEXT, XR_TYPE_SPATIAL_BUFFER_GET_INFO_EXT) \ + _avail(XrSpatialComponentBounded2DListEXT, XR_TYPE_SPATIAL_COMPONENT_BOUNDED_2D_LIST_EXT) \ + _avail(XrSpatialComponentBounded3DListEXT, XR_TYPE_SPATIAL_COMPONENT_BOUNDED_3D_LIST_EXT) \ + _avail(XrSpatialComponentParentListEXT, XR_TYPE_SPATIAL_COMPONENT_PARENT_LIST_EXT) \ + _avail(XrSpatialComponentMesh3DListEXT, XR_TYPE_SPATIAL_COMPONENT_MESH_3D_LIST_EXT) \ + _avail(XrSpatialEntityFromIdCreateInfoEXT, XR_TYPE_SPATIAL_ENTITY_FROM_ID_CREATE_INFO_EXT) \ + _avail(XrSpatialUpdateSnapshotCreateInfoEXT, XR_TYPE_SPATIAL_UPDATE_SNAPSHOT_CREATE_INFO_EXT) \ + _avail(XrEventDataSpatialDiscoveryRecommendedEXT, XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT) \ + _avail(XrSpatialFilterTrackingStateEXT, XR_TYPE_SPATIAL_FILTER_TRACKING_STATE_EXT) \ + _avail(XrSpatialCapabilityConfigurationPlaneTrackingEXT, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_PLANE_TRACKING_EXT) \ + _avail(XrSpatialComponentPlaneAlignmentListEXT, XR_TYPE_SPATIAL_COMPONENT_PLANE_ALIGNMENT_LIST_EXT) \ + _avail(XrSpatialComponentMesh2DListEXT, XR_TYPE_SPATIAL_COMPONENT_MESH_2D_LIST_EXT) \ + _avail(XrSpatialComponentPolygon2DListEXT, XR_TYPE_SPATIAL_COMPONENT_POLYGON_2D_LIST_EXT) \ + _avail(XrSpatialComponentPlaneSemanticLabelListEXT, XR_TYPE_SPATIAL_COMPONENT_PLANE_SEMANTIC_LABEL_LIST_EXT) \ + _avail(XrStationaryReferenceSpaceGenerationIdGetInfoEXT, XR_TYPE_STATIONARY_REFERENCE_SPACE_GENERATION_ID_GET_INFO_EXT) \ + _avail(XrStationaryReferenceSpaceGenerationIdResultEXT, XR_TYPE_STATIONARY_REFERENCE_SPACE_GENERATION_ID_RESULT_EXT) \ + _avail(XrSpatialCapabilityConfigurationQrCodeEXT, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_QR_CODE_EXT) \ + _avail(XrSpatialCapabilityConfigurationMicroQrCodeEXT, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_MICRO_QR_CODE_EXT) \ + _avail(XrSpatialCapabilityConfigurationArucoMarkerEXT, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ARUCO_MARKER_EXT) \ + _avail(XrSpatialCapabilityConfigurationAprilTagEXT, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_APRIL_TAG_EXT) \ + _avail(XrSpatialMarkerSizeEXT, XR_TYPE_SPATIAL_MARKER_SIZE_EXT) \ + _avail(XrSpatialMarkerStaticOptimizationEXT, XR_TYPE_SPATIAL_MARKER_STATIC_OPTIMIZATION_EXT) \ + _avail(XrSpatialComponentMarkerListEXT, XR_TYPE_SPATIAL_COMPONENT_MARKER_LIST_EXT) \ + _avail(XrSystemDynamicObjectTrackingPropertiesBD, XR_TYPE_SYSTEM_DYNAMIC_OBJECT_TRACKING_PROPERTIES_BD) \ + _avail(XrSenseDataProviderCreateInfoDynamicObjectBD, XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_DYNAMIC_OBJECT_BD) \ + _avail(XrDynamicObjectDataBD, XR_TYPE_DYNAMIC_OBJECT_DATA_BD) \ + _avail(XrSpatialEntityComponentDataDynamicObjectBD, XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_DYNAMIC_OBJECT_BD) \ + _avail(XrSenseDataFilterDynamicObjectTypeBD, XR_TYPE_SENSE_DATA_FILTER_DYNAMIC_OBJECT_TYPE_BD) \ + _avail(XrSystemDynamicObjectKeyboardPropertiesBD, XR_TYPE_SYSTEM_DYNAMIC_OBJECT_KEYBOARD_PROPERTIES_BD) \ + _avail(XrSystemDynamicObjectMousePropertiesBD, XR_TYPE_SYSTEM_DYNAMIC_OBJECT_MOUSE_PROPERTIES_BD) \ + _avail(XrCameraPropertiesBD, XR_TYPE_CAMERA_PROPERTIES_BD) \ + _avail(XrCameraCapabilitiesBD, XR_TYPE_CAMERA_CAPABILITIES_BD) \ + _avail(XrAvailableCamerasEnumerateInfoBD, XR_TYPE_AVAILABLE_CAMERAS_ENUMERATE_INFO_BD) \ + _avail(XrAvailableCameraBD, XR_TYPE_AVAILABLE_CAMERA_BD) \ + _avail(XrCameraPropertyTypesEnumerateInfoBD, XR_TYPE_CAMERA_PROPERTY_TYPES_ENUMERATE_INFO_BD) \ + _avail(XrCameraPropertyTypesBD, XR_TYPE_CAMERA_PROPERTY_TYPES_BD) \ + _avail(XrCameraPropertiesGetInfoBD, XR_TYPE_CAMERA_PROPERTIES_GET_INFO_BD) \ + _avail(XrCameraPropertyFacingBD, XR_TYPE_CAMERA_PROPERTY_FACING_BD) \ + _avail(XrCameraPropertyPositionBD, XR_TYPE_CAMERA_PROPERTY_POSITION_BD) \ + _avail(XrCameraPropertyCameraTypeBD, XR_TYPE_CAMERA_PROPERTY_CAMERA_TYPE_BD) \ + _avail(XrCameraCapabilityTypesEnumerateInfoBD, XR_TYPE_CAMERA_CAPABILITY_TYPES_ENUMERATE_INFO_BD) \ + _avail(XrCameraCapabilityTypesBD, XR_TYPE_CAMERA_CAPABILITY_TYPES_BD) \ + _avail(XrCameraSupportedCapabilitiesGetInfoBD, XR_TYPE_CAMERA_SUPPORTED_CAPABILITIES_GET_INFO_BD) \ + _avail(XrCameraSupportedCapabilitiesBD, XR_TYPE_CAMERA_SUPPORTED_CAPABILITIES_BD) \ + _avail(XrCameraSupportedCapabilityImageResolutionAndFrameRateBD, XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_IMAGE_RESOLUTION_AND_FRAME_RATE_BD) \ + _avail(XrCameraCapabilityImageResolutionAndFrameRateBD, XR_TYPE_CAMERA_CAPABILITY_IMAGE_RESOLUTION_AND_FRAME_RATE_BD) \ + _avail(XrCameraSupportedCapabilityDataTransferTypeBD, XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_DATA_TRANSFER_TYPE_BD) \ + _avail(XrCameraCapabilityDataTransferTypeBD, XR_TYPE_CAMERA_CAPABILITY_DATA_TRANSFER_TYPE_BD) \ + _avail(XrCameraSupportedCapabilityImageFormatBD, XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_IMAGE_FORMAT_BD) \ + _avail(XrCameraCapabilityImageFormatBD, XR_TYPE_CAMERA_CAPABILITY_IMAGE_FORMAT_BD) \ + _avail(XrCameraSupportedCapabilityCameraModelBD, XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_CAMERA_MODEL_BD) \ + _avail(XrCameraCapabilityCameraModelBD, XR_TYPE_CAMERA_CAPABILITY_CAMERA_MODEL_BD) \ + _avail(XrCameraDeviceCreateInfoBD, XR_TYPE_CAMERA_DEVICE_CREATE_INFO_BD) \ + _avail(XrCreateCameraDeviceCompletionBD, XR_TYPE_CREATE_CAMERA_DEVICE_COMPLETION_BD) \ + _avail(XrCameraCaptureSessionCreateInfoBD, XR_TYPE_CAMERA_CAPTURE_SESSION_CREATE_INFO_BD) \ + _avail(XrCreateCameraCaptureSessionCompletionBD, XR_TYPE_CREATE_CAMERA_CAPTURE_SESSION_COMPLETION_BD) \ + _avail(XrCameraIntrinsicsBD, XR_TYPE_CAMERA_INTRINSICS_BD) \ + _avail(XrCameraExtrinsicsBD, XR_TYPE_CAMERA_EXTRINSICS_BD) \ + _avail(XrCameraCaptureBeginInfoBD, XR_TYPE_CAMERA_CAPTURE_BEGIN_INFO_BD) \ + _avail(XrCameraImageAcquireInfoBD, XR_TYPE_CAMERA_IMAGE_ACQUIRE_INFO_BD) \ + _avail(XrCameraImageBD, XR_TYPE_CAMERA_IMAGE_BD) \ + _avail(XrCameraImageDataRawBufferBD, XR_TYPE_CAMERA_IMAGE_DATA_RAW_BUFFER_BD) \ + _avail(XrSpatialBoundsSpherefANDROID, XR_TYPE_SPATIAL_BOUNDS_SPHEREF_ANDROID) \ + _avail(XrSpatialBoundsBoxfANDROID, XR_TYPE_SPATIAL_BOUNDS_BOXF_ANDROID) \ + _avail(XrSpatialBoundsFrustumfANDROID, XR_TYPE_SPATIAL_BOUNDS_FRUSTUMF_ANDROID) \ + _avail(XrSpatialCapabilityConfigurationAnchorEXT, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ANCHOR_EXT) \ + _avail(XrSpatialComponentAnchorListEXT, XR_TYPE_SPATIAL_COMPONENT_ANCHOR_LIST_EXT) \ + _avail(XrSpatialAnchorCreateInfoEXT, XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_EXT) \ + _avail(XrSpatialPersistenceContextCreateInfoEXT, XR_TYPE_SPATIAL_PERSISTENCE_CONTEXT_CREATE_INFO_EXT) \ + _avail(XrCreateSpatialPersistenceContextCompletionEXT, XR_TYPE_CREATE_SPATIAL_PERSISTENCE_CONTEXT_COMPLETION_EXT) \ + _avail(XrSpatialContextPersistenceConfigEXT, XR_TYPE_SPATIAL_CONTEXT_PERSISTENCE_CONFIG_EXT) \ + _avail(XrSpatialDiscoveryPersistenceUuidFilterEXT, XR_TYPE_SPATIAL_DISCOVERY_PERSISTENCE_UUID_FILTER_EXT) \ + _avail(XrSpatialComponentPersistenceListEXT, XR_TYPE_SPATIAL_COMPONENT_PERSISTENCE_LIST_EXT) \ + _avail(XrHapticParametricPropertiesEXT, XR_TYPE_HAPTIC_PARAMETRIC_PROPERTIES_EXT) \ + _avail(XrHapticParametricVibrationEXT, XR_TYPE_HAPTIC_PARAMETRIC_VIBRATION_EXT) \ + _avail(XrSystemHapticParametricPropertiesEXT, XR_TYPE_SYSTEM_HAPTIC_PARAMETRIC_PROPERTIES_EXT) \ + _avail(XrColorSpacesEnumerateInfoSONY, XR_TYPE_COLOR_SPACES_ENUMERATE_INFO_SONY) \ + _avail(XrSwapchainCreateInfoColorSpaceSONY, XR_TYPE_SWAPCHAIN_CREATE_INFO_COLOR_SPACE_SONY) \ + _avail(XrHdrMetadataSONY, XR_TYPE_HDR_METADATA_SONY) \ + _avail(XrSpatialEntityPersistInfoEXT, XR_TYPE_SPATIAL_ENTITY_PERSIST_INFO_EXT) \ + _avail(XrPersistSpatialEntityCompletionEXT, XR_TYPE_PERSIST_SPATIAL_ENTITY_COMPLETION_EXT) \ + _avail(XrSpatialEntityUnpersistInfoEXT, XR_TYPE_SPATIAL_ENTITY_UNPERSIST_INFO_EXT) \ + _avail(XrUnpersistSpatialEntityCompletionEXT, XR_TYPE_UNPERSIST_SPATIAL_ENTITY_COMPLETION_EXT) \ + _avail(XrSpatialReferenceImageEXT, XR_TYPE_SPATIAL_REFERENCE_IMAGE_EXT) \ + _avail(XrSpatialImageStaticOptimizationEXT, XR_TYPE_SPATIAL_IMAGE_STATIC_OPTIMIZATION_EXT) \ + _avail(XrSpatialImageSizeEXT, XR_TYPE_SPATIAL_IMAGE_SIZE_EXT) \ + _avail(XrSpatialCapabilityConfigurationImageTrackingEXT, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_IMAGE_TRACKING_EXT) \ + _avail(XrSpatialImageTrackingDatabaseCreateInfoEXT, XR_TYPE_SPATIAL_IMAGE_TRACKING_DATABASE_CREATE_INFO_EXT) \ + _avail(XrSpatialComponentImage2DListEXT, XR_TYPE_SPATIAL_COMPONENT_IMAGE_2D_LIST_EXT) \ + _avail(XrCreateSpatialImageTrackingDatabaseCompletionEXT, XR_TYPE_CREATE_SPATIAL_IMAGE_TRACKING_DATABASE_COMPLETION_EXT) \ + _avail(XrSpatialCapabilityConfigurationObjectTrackingANDROID, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_OBJECT_TRACKING_ANDROID) \ + _avail(XrSpatialComponentObjectSemanticLabelListANDROID, XR_TYPE_SPATIAL_COMPONENT_OBJECT_SEMANTIC_LABEL_LIST_ANDROID) \ + _avail(XrSpatialCapabilityConfigurationDepthRaycastANDROID, XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_DEPTH_RAYCAST_ANDROID) \ + _avail(XrSpatialRaycastInfoANDROID, XR_TYPE_SPATIAL_RAYCAST_INFO_ANDROID) \ + _avail(XrSpatialComponentRaycastResultListANDROID, XR_TYPE_SPATIAL_COMPONENT_RAYCAST_RESULT_LIST_ANDROID) \ + _avail(XrSpatialRaycastSnapshotCreateInfoANDROID, XR_TYPE_SPATIAL_RAYCAST_SNAPSHOT_CREATE_INFO_ANDROID) \ + _avail(XrGoogleCloudAuthInfoApiKeyANDROID, XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_API_KEY_ANDROID) \ + _avail(XrGoogleCloudAuthInfoTokenANDROID, XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_TOKEN_ANDROID) \ + _avail(XrGoogleCloudAuthInfoKeylessANDROID, XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_KEYLESS_ANDROID) \ + _avail(XrGoogleCloudAuthErrorResultANDROID, XR_TYPE_GOOGLE_CLOUD_AUTH_ERROR_RESULT_ANDROID) \ + _avail(XrSystemGeospatialPropertiesANDROID, XR_TYPE_SYSTEM_GEOSPATIAL_PROPERTIES_ANDROID) \ + _avail(XrGeospatialTrackerCreateInfoANDROID, XR_TYPE_GEOSPATIAL_TRACKER_CREATE_INFO_ANDROID) \ + _avail(XrEventDataGeospatialTrackerStateChangedANDROID, XR_TYPE_EVENT_DATA_GEOSPATIAL_TRACKER_STATE_CHANGED_ANDROID) \ + _avail(XrGeospatialPoseFromPoseLocateInfoANDROID, XR_TYPE_GEOSPATIAL_POSE_FROM_POSE_LOCATE_INFO_ANDROID) \ + _avail(XrGeospatialPoseResultANDROID, XR_TYPE_GEOSPATIAL_POSE_RESULT_ANDROID) \ + _avail(XrGeospatialPoseLocateInfoANDROID, XR_TYPE_GEOSPATIAL_POSE_LOCATE_INFO_ANDROID) \ + _avail(XrVPSAvailabilityCheckCompletionANDROID, XR_TYPE_VPS_AVAILABILITY_CHECK_COMPLETION_ANDROID) \ + _avail(XrSpatialAnchorParentANDROID, XR_TYPE_SPATIAL_ANCHOR_PARENT_ANDROID) \ + _avail(XrSpatialDiscoveryUniqueEntitiesFilterANDROID, XR_TYPE_SPATIAL_DISCOVERY_UNIQUE_ENTITIES_FILTER_ANDROID) \ + _avail(XrSpatialComponentSubsumedByListANDROID, XR_TYPE_SPATIAL_COMPONENT_SUBSUMED_BY_LIST_ANDROID) \ + _avail(XrSpatialAnchorSpaceFromIdCreateInfoANDROID, XR_TYPE_SPATIAL_ANCHOR_SPACE_FROM_ID_CREATE_INFO_ANDROID) \ + _avail(XrSystemGeospatialAnchorPropertiesANDROID, XR_TYPE_SYSTEM_GEOSPATIAL_ANCHOR_PROPERTIES_ANDROID) \ + _avail(XrGeospatialTrackerAnchorTrackingInfoANDROID, XR_TYPE_GEOSPATIAL_TRACKER_ANCHOR_TRACKING_INFO_ANDROID) \ + _avail(XrGeospatialAnchorCreateInfoANDROID, XR_TYPE_GEOSPATIAL_ANCHOR_CREATE_INFO_ANDROID) \ + _avail(XrSurfaceAnchorCreateInfoANDROID, XR_TYPE_SURFACE_ANCHOR_CREATE_INFO_ANDROID) \ + _avail(XrSurfaceAnchorCreateCompletionANDROID, XR_TYPE_SURFACE_ANCHOR_CREATE_COMPLETION_ANDROID) \ + _avail(XrSessionCreateInfoSpatialContainersEXT, XR_TYPE_SESSION_CREATE_INFO_SPATIAL_CONTAINERS_EXT) \ + _avail(XrSpatialContainerCreateInfoEXT, XR_TYPE_SPATIAL_CONTAINER_CREATE_INFO_EXT) \ + _avail(XrSpatialContainerSpaceCreateInfoEXT, XR_TYPE_SPATIAL_CONTAINER_SPACE_CREATE_INFO_EXT) \ + _avail(XrEventDataSpatialContainerClosedEXT, XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_CLOSED_EXT) \ + _avail(XrSystemSpatialContainerPropertiesEXT, XR_TYPE_SYSTEM_SPATIAL_CONTAINER_PROPERTIES_EXT) \ + _avail(XrSpatialContainerBoundsEXT, XR_TYPE_SPATIAL_CONTAINER_BOUNDS_EXT) \ + _avail(XrEventDataSpatialContainerBoundsChangedEXT, XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_BOUNDS_CHANGED_EXT) \ + _avail(XrSpatialContainerBoundsGetInfoEXT, XR_TYPE_SPATIAL_CONTAINER_BOUNDS_GET_INFO_EXT) \ + _avail(XrSpatialContainerStateGetInfoEXT, XR_TYPE_SPATIAL_CONTAINER_STATE_GET_INFO_EXT) \ + _avail(XrSpatialContainerVisibleRequestInfoEXT, XR_TYPE_SPATIAL_CONTAINER_VISIBLE_REQUEST_INFO_EXT) \ + _avail(XrEventDataSpatialContainerVisibleChangedEXT, XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_VISIBLE_CHANGED_EXT) \ + _avail(XrEventDataSpatialContainerVisibleRequestDeniedEXT, XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_VISIBLE_REQUEST_DENIED_EXT) \ + _avail(XrEventDataSpatialContainerInteractableChangedEXT, XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_INTERACTABLE_CHANGED_EXT) \ + _avail(XrSpatialContainerBoundsModeRequestInfoEXT, XR_TYPE_SPATIAL_CONTAINER_BOUNDS_MODE_REQUEST_INFO_EXT) \ + _avail(XrEventDataSpatialContainerBoundsModeRequestDeniedEXT, XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_BOUNDS_MODE_REQUEST_DENIED_EXT) \ + _avail(XrSpatialContainerStateEXT, XR_TYPE_SPATIAL_CONTAINER_STATE_EXT) \ + _avail(XrSpatialContainerViewLocateInfoEXT, XR_TYPE_SPATIAL_CONTAINER_VIEW_LOCATE_INFO_EXT) \ + _avail(XrSpatialContainerViewsLocateInfoEXT, XR_TYPE_SPATIAL_CONTAINER_VIEWS_LOCATE_INFO_EXT) \ + _avail(XrSpatialContainerViewStateEXT, XR_TYPE_SPATIAL_CONTAINER_VIEW_STATE_EXT) \ + _avail(XrSpatialContainerLayerEXT, XR_TYPE_SPATIAL_CONTAINER_LAYER_EXT) \ + _avail(XrSpatialContainerLayerFrameEndInfoEXT, XR_TYPE_SPATIAL_CONTAINER_LAYER_FRAME_END_INFO_EXT) \ + _avail(XrSpatialContainerBeginInfoEXT, XR_TYPE_SPATIAL_CONTAINER_BEGIN_INFO_EXT) \ + _avail(XrSpatialContainerEndInfoEXT, XR_TYPE_SPATIAL_CONTAINER_END_INFO_EXT) \ + _avail(XrSpatialContainerCompositionLayerViewConfigurationEXT, XR_TYPE_SPATIAL_CONTAINER_COMPOSITION_LAYER_VIEW_CONFIGURATION_EXT) \ + _avail(XrSpatialContainerLayerVolumeClippingEXT, XR_TYPE_SPATIAL_CONTAINER_LAYER_VOLUME_CLIPPING_EXT) \ + _avail(XrBatteryStateDisplayEXT, XR_TYPE_BATTERY_STATE_DISPLAY_EXT) \ + _avail(XrLoaderInitInfoPropertiesEXT, XR_TYPE_LOADER_INIT_INFO_PROPERTIES_EXT) \ + _avail(XrEventDataViewConfigurationViewsChangedEXT, XR_TYPE_EVENT_DATA_VIEW_CONFIGURATION_VIEWS_CHANGED_EXT) \ + + +#if defined(XR_USE_GRAPHICS_API_D3D11) +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_D3D11(_avail, _unavail) \ + _avail(XrGraphicsBindingD3D11KHR, XR_TYPE_GRAPHICS_BINDING_D3D11_KHR) \ + _avail(XrSwapchainImageD3D11KHR, XR_TYPE_SWAPCHAIN_IMAGE_D3D11_KHR) \ + _avail(XrGraphicsRequirementsD3D11KHR, XR_TYPE_GRAPHICS_REQUIREMENTS_D3D11_KHR) \ + +#else +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_D3D11(_avail, _unavail) \ + _unavail(XrGraphicsBindingD3D11KHR, XR_TYPE_GRAPHICS_BINDING_D3D11_KHR) \ + _unavail(XrSwapchainImageD3D11KHR, XR_TYPE_SWAPCHAIN_IMAGE_D3D11_KHR) \ + _unavail(XrGraphicsRequirementsD3D11KHR, XR_TYPE_GRAPHICS_REQUIREMENTS_D3D11_KHR) \ + +#endif + +#if defined(XR_USE_GRAPHICS_API_D3D12) +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_D3D12(_avail, _unavail) \ + _avail(XrGraphicsBindingD3D12KHR, XR_TYPE_GRAPHICS_BINDING_D3D12_KHR) \ + _avail(XrSwapchainImageD3D12KHR, XR_TYPE_SWAPCHAIN_IMAGE_D3D12_KHR) \ + _avail(XrGraphicsRequirementsD3D12KHR, XR_TYPE_GRAPHICS_REQUIREMENTS_D3D12_KHR) \ + +#else +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_D3D12(_avail, _unavail) \ + _unavail(XrGraphicsBindingD3D12KHR, XR_TYPE_GRAPHICS_BINDING_D3D12_KHR) \ + _unavail(XrSwapchainImageD3D12KHR, XR_TYPE_SWAPCHAIN_IMAGE_D3D12_KHR) \ + _unavail(XrGraphicsRequirementsD3D12KHR, XR_TYPE_GRAPHICS_REQUIREMENTS_D3D12_KHR) \ + +#endif + +#if defined(XR_USE_GRAPHICS_API_METAL) +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_METAL(_avail, _unavail) \ + _avail(XrGraphicsBindingMetalKHR, XR_TYPE_GRAPHICS_BINDING_METAL_KHR) \ + _avail(XrSwapchainImageMetalKHR, XR_TYPE_SWAPCHAIN_IMAGE_METAL_KHR) \ + _avail(XrGraphicsRequirementsMetalKHR, XR_TYPE_GRAPHICS_REQUIREMENTS_METAL_KHR) \ + +#else +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_METAL(_avail, _unavail) \ + _unavail(XrGraphicsBindingMetalKHR, XR_TYPE_GRAPHICS_BINDING_METAL_KHR) \ + _unavail(XrSwapchainImageMetalKHR, XR_TYPE_SWAPCHAIN_IMAGE_METAL_KHR) \ + _unavail(XrGraphicsRequirementsMetalKHR, XR_TYPE_GRAPHICS_REQUIREMENTS_METAL_KHR) \ + +#endif + +#if defined(XR_USE_GRAPHICS_API_OPENGL) +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL(_avail, _unavail) \ + _avail(XrSwapchainImageOpenGLKHR, XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_KHR) \ + _avail(XrGraphicsRequirementsOpenGLKHR, XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_KHR) \ + +#else +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL(_avail, _unavail) \ + _unavail(XrSwapchainImageOpenGLKHR, XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_KHR) \ + _unavail(XrGraphicsRequirementsOpenGLKHR, XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_KHR) \ + +#endif + +#if defined(XR_USE_GRAPHICS_API_OPENGL) && defined(XR_USE_PLATFORM_WAYLAND) +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_WAYLAND(_avail, _unavail) \ + _avail(XrGraphicsBindingOpenGLWaylandKHR, XR_TYPE_GRAPHICS_BINDING_OPENGL_WAYLAND_KHR) \ + +#else +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_WAYLAND(_avail, _unavail) \ + _unavail(XrGraphicsBindingOpenGLWaylandKHR, XR_TYPE_GRAPHICS_BINDING_OPENGL_WAYLAND_KHR) \ + +#endif + +#if defined(XR_USE_GRAPHICS_API_OPENGL) && defined(XR_USE_PLATFORM_WIN32) +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_WIN32(_avail, _unavail) \ + _avail(XrGraphicsBindingOpenGLWin32KHR, XR_TYPE_GRAPHICS_BINDING_OPENGL_WIN32_KHR) \ + +#else +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_WIN32(_avail, _unavail) \ + _unavail(XrGraphicsBindingOpenGLWin32KHR, XR_TYPE_GRAPHICS_BINDING_OPENGL_WIN32_KHR) \ + +#endif + +#if defined(XR_USE_GRAPHICS_API_OPENGL) && defined(XR_USE_PLATFORM_XCB) +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_XCB(_avail, _unavail) \ + _avail(XrGraphicsBindingOpenGLXcbKHR, XR_TYPE_GRAPHICS_BINDING_OPENGL_XCB_KHR) \ + +#else +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_XCB(_avail, _unavail) \ + _unavail(XrGraphicsBindingOpenGLXcbKHR, XR_TYPE_GRAPHICS_BINDING_OPENGL_XCB_KHR) \ + +#endif + +#if defined(XR_USE_GRAPHICS_API_OPENGL) && defined(XR_USE_PLATFORM_XLIB) +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_XLIB(_avail, _unavail) \ + _avail(XrGraphicsBindingOpenGLXlibKHR, XR_TYPE_GRAPHICS_BINDING_OPENGL_XLIB_KHR) \ + +#else +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_XR_USE_PLATFORM_XLIB(_avail, _unavail) \ + _unavail(XrGraphicsBindingOpenGLXlibKHR, XR_TYPE_GRAPHICS_BINDING_OPENGL_XLIB_KHR) \ + +#endif + +#if defined(XR_USE_GRAPHICS_API_OPENGL_ES) +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_ES(_avail, _unavail) \ + _avail(XrSwapchainImageOpenGLESKHR, XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR) \ + _avail(XrGraphicsRequirementsOpenGLESKHR, XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_ES_KHR) \ + _avail(XrSwapchainStateSamplerOpenGLESFB, XR_TYPE_SWAPCHAIN_STATE_SAMPLER_OPENGL_ES_FB) \ + +#else +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_ES(_avail, _unavail) \ + _unavail(XrSwapchainImageOpenGLESKHR, XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR) \ + _unavail(XrGraphicsRequirementsOpenGLESKHR, XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_ES_KHR) \ + _unavail(XrSwapchainStateSamplerOpenGLESFB, XR_TYPE_SWAPCHAIN_STATE_SAMPLER_OPENGL_ES_FB) \ + +#endif + +#if defined(XR_USE_GRAPHICS_API_OPENGL_ES) && defined(XR_USE_PLATFORM_ANDROID) +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_ES_XR_USE_PLATFORM_ANDROID(_avail, _unavail) \ + _avail(XrGraphicsBindingOpenGLESAndroidKHR, XR_TYPE_GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR) \ + +#else +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_OPENGL_ES_XR_USE_PLATFORM_ANDROID(_avail, _unavail) \ + _unavail(XrGraphicsBindingOpenGLESAndroidKHR, XR_TYPE_GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR) \ + +#endif + +#if defined(XR_USE_GRAPHICS_API_VULKAN) +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_VULKAN(_avail, _unavail) \ + _avail(XrVulkanSwapchainFormatListCreateInfoKHR, XR_TYPE_VULKAN_SWAPCHAIN_FORMAT_LIST_CREATE_INFO_KHR) \ + _avail(XrGraphicsBindingVulkanKHR, XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR) \ + _avail(XrSwapchainImageVulkanKHR, XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR) \ + _avail(XrGraphicsRequirementsVulkanKHR, XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR) \ + _avail(XrVulkanInstanceCreateInfoKHR, XR_TYPE_VULKAN_INSTANCE_CREATE_INFO_KHR) \ + _avail(XrVulkanDeviceCreateInfoKHR, XR_TYPE_VULKAN_DEVICE_CREATE_INFO_KHR) \ + _avail(XrVulkanGraphicsDeviceGetInfoKHR, XR_TYPE_VULKAN_GRAPHICS_DEVICE_GET_INFO_KHR) \ + _avail(XrSwapchainImageFoveationVulkanFB, XR_TYPE_SWAPCHAIN_IMAGE_FOVEATION_VULKAN_FB) \ + _avail(XrSwapchainStateSamplerVulkanFB, XR_TYPE_SWAPCHAIN_STATE_SAMPLER_VULKAN_FB) \ + _avail(XrVulkanSwapchainCreateInfoMETA, XR_TYPE_VULKAN_SWAPCHAIN_CREATE_INFO_META) \ + +#else +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_GRAPHICS_API_VULKAN(_avail, _unavail) \ + _unavail(XrVulkanSwapchainFormatListCreateInfoKHR, XR_TYPE_VULKAN_SWAPCHAIN_FORMAT_LIST_CREATE_INFO_KHR) \ + _unavail(XrGraphicsBindingVulkanKHR, XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR) \ + _unavail(XrSwapchainImageVulkanKHR, XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR) \ + _unavail(XrGraphicsRequirementsVulkanKHR, XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR) \ + _unavail(XrVulkanInstanceCreateInfoKHR, XR_TYPE_VULKAN_INSTANCE_CREATE_INFO_KHR) \ + _unavail(XrVulkanDeviceCreateInfoKHR, XR_TYPE_VULKAN_DEVICE_CREATE_INFO_KHR) \ + _unavail(XrVulkanGraphicsDeviceGetInfoKHR, XR_TYPE_VULKAN_GRAPHICS_DEVICE_GET_INFO_KHR) \ + _unavail(XrSwapchainImageFoveationVulkanFB, XR_TYPE_SWAPCHAIN_IMAGE_FOVEATION_VULKAN_FB) \ + _unavail(XrSwapchainStateSamplerVulkanFB, XR_TYPE_SWAPCHAIN_STATE_SAMPLER_VULKAN_FB) \ + _unavail(XrVulkanSwapchainCreateInfoMETA, XR_TYPE_VULKAN_SWAPCHAIN_CREATE_INFO_META) \ + +#endif + +#if defined(XR_USE_PLATFORM_ANDROID) +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_PLATFORM_ANDROID(_avail, _unavail) \ + _avail(XrInstanceCreateInfoAndroidKHR, XR_TYPE_INSTANCE_CREATE_INFO_ANDROID_KHR) \ + _avail(XrLoaderInitInfoAndroidKHR, XR_TYPE_LOADER_INIT_INFO_ANDROID_KHR) \ + _avail(XrAndroidSurfaceSwapchainCreateInfoFB, XR_TYPE_ANDROID_SURFACE_SWAPCHAIN_CREATE_INFO_FB) \ + _avail(XrSwapchainStateAndroidSurfaceDimensionsFB, XR_TYPE_SWAPCHAIN_STATE_ANDROID_SURFACE_DIMENSIONS_FB) \ + _avail(XrAnchorSharingInfoANDROID, XR_TYPE_ANCHOR_SHARING_INFO_ANDROID) \ + _avail(XrAnchorSharingTokenANDROID, XR_TYPE_ANCHOR_SHARING_TOKEN_ANDROID) \ + _avail(XrSystemAnchorSharingExportPropertiesANDROID, XR_TYPE_SYSTEM_ANCHOR_SHARING_EXPORT_PROPERTIES_ANDROID) \ + +#else +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_PLATFORM_ANDROID(_avail, _unavail) \ + _unavail(XrInstanceCreateInfoAndroidKHR, XR_TYPE_INSTANCE_CREATE_INFO_ANDROID_KHR) \ + _unavail(XrLoaderInitInfoAndroidKHR, XR_TYPE_LOADER_INIT_INFO_ANDROID_KHR) \ + _unavail(XrAndroidSurfaceSwapchainCreateInfoFB, XR_TYPE_ANDROID_SURFACE_SWAPCHAIN_CREATE_INFO_FB) \ + _unavail(XrSwapchainStateAndroidSurfaceDimensionsFB, XR_TYPE_SWAPCHAIN_STATE_ANDROID_SURFACE_DIMENSIONS_FB) \ + _unavail(XrAnchorSharingInfoANDROID, XR_TYPE_ANCHOR_SHARING_INFO_ANDROID) \ + _unavail(XrAnchorSharingTokenANDROID, XR_TYPE_ANCHOR_SHARING_TOKEN_ANDROID) \ + _unavail(XrSystemAnchorSharingExportPropertiesANDROID, XR_TYPE_SYSTEM_ANCHOR_SHARING_EXPORT_PROPERTIES_ANDROID) \ + +#endif + +#if defined(XR_USE_PLATFORM_EGL) +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_PLATFORM_EGL(_avail, _unavail) \ + _avail(XrGraphicsBindingEGLMNDX, XR_TYPE_GRAPHICS_BINDING_EGL_MNDX) \ + +#else +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_PLATFORM_EGL(_avail, _unavail) \ + _unavail(XrGraphicsBindingEGLMNDX, XR_TYPE_GRAPHICS_BINDING_EGL_MNDX) \ + +#endif + +#if defined(XR_USE_PLATFORM_ML) +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_PLATFORM_ML(_avail, _unavail) \ + _avail(XrCoordinateSpaceCreateInfoML, XR_TYPE_COORDINATE_SPACE_CREATE_INFO_ML) \ + +#else +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_PLATFORM_ML(_avail, _unavail) \ + _unavail(XrCoordinateSpaceCreateInfoML, XR_TYPE_COORDINATE_SPACE_CREATE_INFO_ML) \ + +#endif + +#if defined(XR_USE_PLATFORM_WIN32) +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_PLATFORM_WIN32(_avail, _unavail) \ + _avail(XrHolographicWindowAttachmentMSFT, XR_TYPE_HOLOGRAPHIC_WINDOW_ATTACHMENT_MSFT) \ + +#else +#define _impl_XR_LIST_ALL_STRUCTURE_TYPES_XR_USE_PLATFORM_WIN32(_avail, _unavail) \ + _unavail(XrHolographicWindowAttachmentMSFT, XR_TYPE_HOLOGRAPHIC_WINDOW_ATTACHMENT_MSFT) \ + +#endif + + + + +#endif + diff --git a/shadps4-arm64-main/externals/openxr-sdk/specification/registry/xr.fragmented.xml b/shadps4-arm64-main/externals/openxr-sdk/specification/registry/xr.fragmented.xml new file mode 100644 index 0000000..0acc8c1 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/specification/registry/xr.fragmented.xml @@ -0,0 +1,25260 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE registry> +<?xml-model href="registry.rnc" type="application/relax-ng-compact-syntax"?> +<?xml-model href="registry.sch" type="application/xml" schematypens="http://purl.oclc.org/dsdl/schematron"?> +<registry> + <comment> +Copyright (c) 2017-2026 The Khronos Group Inc. + +SPDX-License-Identifier: Apache-2.0 OR MIT + +------------------------------------------------------------------------ + +This file, xr.xml, is the OpenXR API Registry. It is a critically important +and normative part of the OpenXR Specification, including a canonical +machine-readable definition of the API, parameter and member validation +language incorporated into the Specification and reference pages, and other +material which is registered by Khronos, such as tags used by extension and +layer authors. The only authoritative version of xr.xml is the one +maintained in the default branch of the Khronos OpenXR GitHub project. + </comment> + + <!-- SECTION: OpenXR vendor IDs for physical devices without USB vendor IDs --> + <vendorids> + <vendorid name="MND" id="0x10001" comment="Monado Project vendor ID"/> + <vendorid name="KHR" id="0x10002" comment="This is the next available Khronos vendor ID"/> + </vendorids> + + <!-- SECTION: OpenXR vendor/author tags for extensions and layers --> + <tags> + <!-- Sorted alphabetically by tag name --> + <tag name="ACER" author="Acer" contact="OC Lin @aceroc"/> + <tag name="ALMALENCE" author="Almalence" contact="Ivan Chupakhin @ivan.chupakhin, Dmitry Shmunk @dmitry.shmunk"/> + <tag name="ANDROID" author="Google" contact="Nihav Jain @njain_google"/> + <tag name="ANDROIDSYS" author="Google" contact="Nihav Jain @njain_google"/> + <tag name="ARM" author="Arm Limited" contact="Andreas Loeve Selvik @selvik, Sam Martin @sammartin"/> + <tag name="BD" author="ByteDance" contact="Will Fu @willfu, Bangsen Han @Hansenn"/> + <tag name="COLLABORA" author="Collabora" contact="Rylie Pavlik @rpavlik"/> + <tag name="DANWILLM" author="Daniel Willmott" contact="Daniel Willmott @danwillm"/> + <tag name="DEEPMIRROR" author="Deep Mirror" contact="Yuhui Lun @lyh-dm"/> + <tag name="DXR" author="The DisplayXR Project" contact="David Fattal @dfattal"/> + <tag name="EPIC" author="Epic" contact="Nick Whiting @whitingn"/> + <tag name="EXT" author="Multivendor" contact="Rylie Pavlik @rpavlik"/> + <tag name="FB" author="Facebook" contact="Cass Everitt @casseveritt, Jonathan Wright @Nelno"/> + <tag name="FREDEMMOTT" author="Frederick Emmott" contact="Frederick Emmott @fredemmott"/> + <tag name="GOOGLE" author="Google" contact="Kaye Mason @chaleur"/> + <tag name="HOLOLIGHT" author="Holo-Light GmbH" contact="Aidan Howie @aidanhowie, Krzysztof Lesiak @k_lesiak"/> + <tag name="HTC" author="HTC" contact="Chris Kuo @ggkuo, Kyle Chen @kylechen76"/> + <tag name="HUAWEI" author="Huawei" contact="Yihong Huang @rachelhuang, Li jingya @yzljy"/> + <tag name="INTEL" author="Intel" contact="Javier Martinez @javier"/> + <tag name="KHR" author="Khronos" contact="Brent Insko @insko"/> + <tag name="LEIA" author="Leia" contact="Cristina Scheibler @cscheibler"/> + <tag name="LUNARG" author="LunarG" contact="Brad Grantham @bradgrantham-lunarg"/> + <tag name="LIV" author="LIV" contact="Arthur Brainville @Ybalrid, Steffan Donal @liv_ruu"/> + <tag name="LOGITECH" author="Logitech" contact="Mario Gutierrez @mgutierrez1, Fabien Zellweger @fzellweger"/> + <tag name="META" author="Meta Platforms" contact="Cass Everitt @casseveritt, Jonathan Wright @Nelno"/> + <tag name="ML" author="Magic Leap" contact="Ron Bessems @rbessems"/> + <tag name="MND" author="Monado Project" contact="Jakob Bornecrantz @wallbraker, Rylie Pavlik @rpavlik"/> + <tag name="MSFT" author="Microsoft" contact="Alex Turner @alexturn, Yin Li @yl_msft, Bryce Hutchings @brycehutchings, Lachlan Ford @laford_msft, Minmin Gong @gongminmin "/> + <tag name="NV" author="NVIDIA Corporation" contact="Satish Salian @ssalian, Robert Menzel"/> + <tag name="OCULUS" author="Oculus" contact="Cass Everitt @casseveritt, Jonathan Wright @Nelno"/> + <tag name="OPPO" author="OPPO" contact="Buyi Xu @fantastxu, Haomiao Jiang @hjiang36"/> + <tag name="PLUTO" author="Pluto VR" contact="Jared Cheshier @Jared, Sophia Baldonado @sophia"/> + <tag name="QCOM" author="Qualcomm Technologies" contact="Armelle @alaine_qcom, Martin Renschler @martinr"/> + <tag name="RZR" author="Razer" contact="Alexandre Hulsken @ahulsken, Eric Vezzoli @EricVezzoli"/> + <tag name="SONY" author="Sony Corporation" contact="Kota Suzuki @kotasuzuki"/> + <tag name="STARBREEZE" author="Starbreeze" contact="David Srour @dsrour"/> + <tag name="TOBII" author="Tobii" contact="Denny Rönngren @denron"/> + <tag name="ULTRALEAP" author="Ultraleap" contact="Robert Blenkinsopp @rblenkinsopp"/> + <tag name="UNITY" author="Unity Technologies" contact="Jack Pritz @jackpritz, Peter Kuhn @peterunity"/> + <tag name="VALVE" author="Valve" contact="Joe Ludwig @JoeLudwig"/> + <tag name="VARJO" author="Varjo" contact="Denny Rönngren @denron_varjo"/> + <tag name="YVR" author="YVR" contact="Pengpeng Zhang @zhangpengpeng"/> + </tags> + + <!-- SECTION: OpenXR type definitions --> + <types> + <type name="openxr_platform_defines" category="include">#include "openxr_platform_defines.h"</type> + + <type requires="android/binder_ibinder.h" name="AIBinder"/> + <type requires="android/native_window.h" name="ANativeWindow"/> + <type requires="jni.h" name="jobject"/> + <type requires="CL/cl_gl_ext.h" name="CGLContextObj"/> + <type requires="d3dcommon.h" name="D3D_FEATURE_LEVEL"/> + <type requires="D3D11.h" name="ID3D11Device"/> + <type requires="D3D11.h" name="ID3D11Texture2D"/> + <type requires="D3D12.h" name="ID3D12CommandQueue"/> + <type requires="D3D12.h" name="ID3D12Device"/> + <type requires="D3D12.h" name="ID3D12Resource"/> + <type requires="EGL/egl.h" name="EGLDisplay"/> + <type requires="EGL/egl.h" name="EGLConfig"/> + <type requires="EGL/egl.h" name="EGLContext"/> + <type requires="EGL/egl.h" name="EGLenum"/> + <type requires="GL/glxext.h" name="GLXFBConfig"/> + <type requires="GL/glxext.h" name="GLXDrawable"/> + <type requires="GL/glxext.h" name="GLXContext"/> + <type requires="GL/wglext.h" name="HGLRC"/> + <type requires="unknwn.h" name="IUnknown"/> + <type requires="wayland-client.h" name="wl_display"/> + <type requires="windows.h" name="HDC"/> + <type requires="windows.h" name="LUID"/> + <type requires="windows.h" name="LARGE_INTEGER"/> + <type requires="X11/Xlib.h" name="Display"/> + <type requires="X11/Xlib.h" name="VisualID"/> + <type requires="X11/Xlib.h" name="Window"/> + <type requires="xcb/glx.h" name="xcb_glx_fbconfig_t"/> + <type requires="xcb/glx.h" name="xcb_glx_drawable_t"/> + <type requires="xcb/glx.h" name="xcb_glx_context_t"/> + <type requires="xcb/xcb.h" name="xcb_connection_t"/> + <type requires="xcb/xcb.h" name="xcb_visualid_t"/> + <type requires="xcb/xcb.h" name="xcb_window_t"/> + <type requires="vulkan/vulkan.h" name="PFN_vkGetInstanceProcAddr"/> + <type requires="vulkan/vulkan.h" name="VkAllocationCallbacks"/> + <type requires="vulkan/vulkan.h" name="VkComponentSwizzle"/> + <type requires="vulkan/vulkan.h" name="VkDevice"/> + <type requires="vulkan/vulkan.h" name="VkDeviceCreateInfo"/> + <type requires="vulkan/vulkan.h" name="VkFilter"/> + <type requires="vulkan/vulkan.h" name="VkFormat"/> + <type requires="vulkan/vulkan.h" name="VkImage"/> + <type requires="vulkan/vulkan.h" name="VkImageCreateFlags"/> + <type requires="vulkan/vulkan.h" name="VkImageUsageFlags"/> + <type requires="vulkan/vulkan.h" name="VkInstance"/> + <type requires="vulkan/vulkan.h" name="VkInstanceCreateInfo"/> + <type requires="vulkan/vulkan.h" name="VkPhysicalDevice"/> + <type requires="vulkan/vulkan.h" name="VkResult"/> + <type requires="vulkan/vulkan.h" name="VkSamplerAddressMode"/> + <type requires="vulkan/vulkan.h" name="VkSamplerMipmapMode"/> + <type requires="time.h" name="timespec"/> + <type requires="ml_coordinate_frame_uid.h" name="MLCoordinateFrameUID"/> + + <type category="define">#define <name>XR_MAKE_VERSION</name>(major, minor, patch) \ + ((((major) & 0xffffULL) << 48) | (((minor) & 0xffffULL) << 32) | ((patch) & 0xffffffffULL))</type> + <type category="define">#define <name>XR_VERSION_MAJOR</name>(version) (uint16_t)(((uint64_t)(version) >> 48)& 0xffffULL)</type> + <type category="define">#define <name>XR_VERSION_MINOR</name>(version) (uint16_t)(((uint64_t)(version) >> 32) & 0xffffULL)</type> + <type category="define">#define <name>XR_VERSION_PATCH</name>(version) (uint32_t)((uint64_t)(version) & 0xffffffffULL)</type> + + <!-- + NOTE: The following group of lines defining the two version constants + must not be re-arranged or re-flowed, since scripts/update_version.py + updates them automatically by processing a line at a time. + --> + <type category="define">// OpenXR current version number. +#define <name>XR_CURRENT_API_VERSION</name> <type>XR_MAKE_VERSION</type>(1, 1, 63)</type> + + <!-- + Defines for a fixed major.minor version of OpenXR preserving the shared patch version. + --> + <type category="define">// OpenXR 1.0 version number +#define <name>XR_API_VERSION_1_0</name> <type>XR_MAKE_VERSION</type>(1, 0, XR_VERSION_PATCH(XR_CURRENT_API_VERSION))</type> + + <type category="define">// OpenXR 1.1 version number +#define <name>XR_API_VERSION_1_1</name> <type>XR_MAKE_VERSION</type>(1, 1, XR_VERSION_PATCH(XR_CURRENT_API_VERSION))</type> + + <!-- + NOTE: For avoidance of ambiguity, there should only be 1 <name> tag immediately in + each <type>. This is why XR_MAY_ALIAS appears multiple times below, but only once with + the <name> tags wrapping it. It does not particularly matter which of the copies of + names gets marked up, but it seems reasonable that the most meaningful one is marked up. + --> + <type category="define"> +#if !defined(XR_MAY_ALIAS) +#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4)) +#define <name>XR_MAY_ALIAS</name> __attribute__((__may_alias__)) +#else +#define XR_MAY_ALIAS +#endif +#endif</type> + + <type category="define"> +#if !defined(XR_DEFINE_HANDLE) +#if (XR_PTR_SIZE == 8) + #define <name>XR_DEFINE_HANDLE</name>(object) typedef struct object##_T* object; +#else + #define XR_DEFINE_HANDLE(object) typedef uint64_t object; +#endif +#endif</type> + + <type category="define"> +#if !defined(XR_NULL_HANDLE) +#if (XR_PTR_SIZE == 8) && XR_CPP_NULLPTR_SUPPORTED + #define <name>XR_NULL_HANDLE</name> nullptr +#else + #define XR_NULL_HANDLE 0 +#endif +#endif</type> + + <type category="define"> +#if !defined(XR_DEFINE_ATOM) + #define <name>XR_DEFINE_ATOM</name>(object) typedef uint64_t object; +#endif</type> + + <type category="define"> +#if !defined(XR_DEFINE_OPAQUE_64) + #if (XR_PTR_SIZE == 8) + #define <name>XR_DEFINE_OPAQUE_64</name>(object) typedef struct object##_T* object; + #else + #define XR_DEFINE_OPAQUE_64(object) typedef uint64_t object; + #endif +#endif</type> + + <type category="define"> +#define <name>XR_EXTENSION_ENUM_BASE</name> 1000000000</type> + + <type category="define"> +#define <name>XR_EXTENSION_ENUM_STRIDE</name> 1000</type> + + <type category="define"> +#define <name>XR_NULL_PATH</name> 0</type> + + <type category="define"> +#define <name>XR_NULL_SYSTEM_ID</name> 0</type> + + <type category="define"> +#define <name>XR_SUCCEEDED</name>(result) ((result) >= 0)</type> + + <type category="define"> +#define <name>XR_UNQUALIFIED_SUCCESS</name>(result) ((result) == 0)</type> + + <type category="define"> +#define <name>XR_FAILED</name>(result) ((result) < 0)</type> + + <type category="define"> +#define <name>XR_NO_DURATION</name> 0</type> + + <type category="define"> +#define <name>XR_INFINITE_DURATION</name> 0x7fffffffffffffffLL</type> + + <type category="define"> +#define <name>XR_MIN_HAPTIC_DURATION</name> -1</type> + + <type category="define"> +#define <name>XR_FREQUENCY_UNSPECIFIED</name> 0</type> + + <type category="define"> +#define <name>XR_MAX_EVENT_DATA_SIZE</name> sizeof(XrEventDataBuffer)</type> + + <type category="define"> +#define <name>XR_MIN_COMPOSITION_LAYERS_SUPPORTED</name> 16</type> + + <!-- openxr_loader_negotiation.h --> + <type category="define"> +#define <name>XR_CURRENT_LOADER_API_LAYER_VERSION</name> 1</type> + <type category="define"> +#define <name>XR_CURRENT_LOADER_RUNTIME_VERSION</name> 1</type> + <type category="define"> +#define <name>XR_LOADER_INFO_STRUCT_VERSION</name> 1</type> + <type category="define"> +#define <name>XR_API_LAYER_INFO_STRUCT_VERSION</name> 1</type> + <type category="define"> +#define <name>XR_RUNTIME_INFO_STRUCT_VERSION</name> 1</type> + <type category="define"> +#define <name>XR_API_LAYER_NEXT_INFO_STRUCT_VERSION</name> 1</type> + <type category="define"> +#define <name>XR_API_LAYER_CREATE_INFO_STRUCT_VERSION</name> 1</type> + <type category="define"> +#define <name>XR_API_LAYER_MAX_SETTINGS_PATH_SIZE</name> 512</type> + + <!-- XR_EXT_hand_tracking --> + <type category="define"> +#define <name>XR_HAND_JOINT_COUNT_EXT</name> 26</type> + + <!-- XR_BD_body_tracking --> + <type category="define"> +#define <name>XR_BODY_JOINT_COUNT_BD</name> 24</type> + <type category="define"> +#define <name>XR_BODY_JOINT_WITHOUT_ARM_COUNT_BD</name> 16</type> + + <!-- XR_MSFT_controller_model --> + <type category="define"> +#define <name>XR_NULL_CONTROLLER_MODEL_KEY_MSFT</name> 0</type> + + <!-- XR_FB_render_model --> + <type category="define"> +#define <name>XR_NULL_RENDER_MODEL_KEY_FB</name> 0</type> + + <!-- XR_HTC_facial_tracking --> + <type category="define"> +#define <name>XR_FACIAL_EXPRESSION_EYE_COUNT_HTC</name> 14</type> + <type category="define"> +#define <name>XR_FACIAL_EXPRESSION_LIP_COUNT_HTC</name> 37</type> + + <!-- XR_ULTRALEAP_hand_tracking_forearm --> + <type category="define"> +#define <name>XR_HAND_FOREARM_JOINT_COUNT_ULTRALEAP</name> 27</type> + + <!-- XR_FB_face_tracking --> + <type category="define"> +#define <name>XR_FACE_EXPRESSSION_SET_DEFAULT_FB</name> XR_FACE_EXPRESSION_SET_DEFAULT_FB</type> + + <!-- XR_FB_haptic_amplitude_envelope --> + <type category="define"> +#define <name>XR_MAX_HAPTIC_AMPLITUDE_ENVELOPE_SAMPLES_FB</name> 4000u</type> + + <!-- XR_FB_haptic_pcm --> + <type category="define"> +#define <name>XR_MAX_HAPTIC_PCM_BUFFER_SIZE_FB</name> 4000</type> + + <!-- XR_EXT_spatial_entity --> + <type category="define"> +#define <name>XR_NULL_SPATIAL_ENTITY_ID_EXT</name> 0</type> + + <type category="define"> +#define <name>XR_NULL_SPATIAL_BUFFER_ID_EXT</name> 0</type> + + <!-- XR_HTC_body_tracking --> + <type category="define"> +#define <name>XR_BODY_JOINT_COUNT_HTC</name> 26</type> + + <!-- XR_BD_facial_simulation--> + <type category="define"> +#define <name>XR_FACE_EXPRESSION_COUNT_BD</name> 52</type> + <type category="define"> +#define <name>XR_LIP_EXPRESSION_COUNT_BD</name> 20</type> + + + <!-- XR_EXT_haptic_parametric --> + <type category="define"> +#define <name>XR_HAPTIC_PARAMETRIC_MAX_POINTS_TRANSIENTS_EXT</name> 500</type> + <type category="define"> +#define <name>XR_HAPTIC_PARAMETRIC_VIBRATION_EXTEND_DURATION_EXT</name> 50000000</type> + <type category="define"> +#define <name>XR_HAPTIC_PARAMETRIC_FREQUENCY_MIN_HZ_EXT</name> 1</type> + <type category="define"> +#define <name>XR_HAPTIC_PARAMETRIC_FREQUENCY_MAX_HZ_EXT</name> 1000</type> + + <!-- Value types --> + <type category="basetype">typedef <type>uint32_t</type> <name>XrBool32</name>;</type> + <type category="basetype">typedef <type>uint64_t</type> <name>XrFlags64</name>;</type> + <type category="basetype">typedef <type>int64_t</type> <name>XrTime</name>;</type> + <type category="basetype">typedef <type>int64_t</type> <name>XrDuration</name>;</type> + <type category="basetype">typedef <type>uint64_t</type> <name>XrVersion</name>;</type> + + <!-- XR_FB_spatial_entity_user --> + <type category="basetype">typedef <type>uint64_t</type> <name>XrSpaceUserIdFB</name>;</type> + + <!-- Atoms, allocated by the runtime (if implementation requires) and never freed --> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrPath</name>)</type> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrSystemId</name>)</type> + <!-- XR_MSFT_controller_model --> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrControllerModelKeyMSFT</name>)</type> + <!-- XR_FB_spatial_entity --> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrAsyncRequestIdFB</name>)</type> + <!-- XR_FB_render_model --> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrRenderModelKeyFB</name>)</type> + <!-- XR_ML_marker_understanding --> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrMarkerML</name>)</type> + <!-- XR_EXT_render_model --> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrRenderModelIdEXT</name>)</type> + <!-- XR_EXT_spatial_entity --> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrSpatialEntityIdEXT</name>)</type> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrSpatialBufferIdEXT</name>)</type> + + <!-- Basic C types, pulled in via openxr_platform_defines.h --> + <type requires="openxr_platform_defines" name="void"/> + <type requires="openxr_platform_defines" name="char"/> + <type requires="openxr_platform_defines" name="wchar_t"/> + <type requires="openxr_platform_defines" name="float"/> + <type requires="openxr_platform_defines" name="int8_t"/> + <type requires="openxr_platform_defines" name="uint8_t"/> + <type requires="openxr_platform_defines" name="int16_t"/> + <type requires="openxr_platform_defines" name="uint16_t"/> + <type requires="openxr_platform_defines" name="int32_t"/> + <type requires="openxr_platform_defines" name="uint32_t"/> + <type requires="openxr_platform_defines" name="int64_t"/> + <type requires="openxr_platform_defines" name="uint64_t"/> + <type requires="openxr_platform_defines" name="size_t"/> + <type requires="openxr_platform_defines" name="uintptr_t"/> + + <!-- XR_KHR_maintenance1 --> + <type requires="openxr_platform_defines" name="double"/> + + <!-- Bitmask types --> + <type bitvalues="XrInstanceCreateFlagBits" category="bitmask">typedef <type>XrFlags64</type> <name>XrInstanceCreateFlags</name>;</type> + <type bitvalues="XrSessionCreateFlagBits" category="bitmask">typedef <type>XrFlags64</type> <name>XrSessionCreateFlags</name>;</type> + <type bitvalues="XrSwapchainCreateFlagBits" category="bitmask">typedef <type>XrFlags64</type> <name>XrSwapchainCreateFlags</name>;</type> + <type bitvalues="XrSwapchainUsageFlagBits" category="bitmask">typedef <type>XrFlags64</type> <name>XrSwapchainUsageFlags</name>;</type> + <type bitvalues="XrViewStateFlagBits" category="bitmask">typedef <type>XrFlags64</type> <name>XrViewStateFlags</name>;</type> + <type bitvalues="XrCompositionLayerFlagBits" category="bitmask">typedef <type>XrFlags64</type> <name>XrCompositionLayerFlags</name>;</type> + <type bitvalues="XrSpaceLocationFlagBits" category="bitmask">typedef <type>XrFlags64</type> <name>XrSpaceLocationFlags</name>;</type> + <type bitvalues="XrSpaceVelocityFlagBits" category="bitmask">typedef <type>XrFlags64</type> <name>XrSpaceVelocityFlags</name>;</type> + <type bitvalues="XrInputSourceLocalizedNameFlagBits" category="bitmask">typedef <type>XrFlags64</type> <name>XrInputSourceLocalizedNameFlags</name>;</type> + + <!-- Bitmask types for XR_KHR_vulkan_enable2 --> + <type bitvalues="XrVulkanInstanceCreateFlagBitsKHR" category="bitmask">typedef <type>XrFlags64</type> <name>XrVulkanInstanceCreateFlagsKHR</name>;</type> + <type bitvalues="XrVulkanDeviceCreateFlagBitsKHR" category="bitmask">typedef <type>XrFlags64</type> <name>XrVulkanDeviceCreateFlagsKHR</name>;</type> + + <!-- Bitmask types for XR_EXT_debug_utils --> + <type bitvalues="XrDebugUtilsMessageSeverityFlagBitsEXT" category="bitmask">typedef <type>XrFlags64</type> <name>XrDebugUtilsMessageSeverityFlagsEXT</name>;</type> + <type bitvalues="XrDebugUtilsMessageTypeFlagBitsEXT" category="bitmask">typedef <type>XrFlags64</type> <name>XrDebugUtilsMessageTypeFlagsEXT</name>;</type> + + <!-- Bitmask types for XR_EXT_frame_synthesis --> + <type bitvalues="XrFrameSynthesisInfoFlagBitsEXT" category="bitmask">typedef <type>XrFlags64</type> <name>XrFrameSynthesisInfoFlagsEXT</name>;</type> + + <!-- Bitmask types for XR_EXTX_overlay --> + <type bitvalues="XrOverlayMainSessionFlagBitsEXTX" category="bitmask">typedef <type>XrFlags64</type> <name>XrOverlayMainSessionFlagsEXTX</name>;</type> + <type bitvalues="XrOverlaySessionCreateFlagBitsEXTX" category="bitmask">typedef <type>XrFlags64</type> <name>XrOverlaySessionCreateFlagsEXTX</name>;</type> + + <!-- Bitmask types for XR_FB_android_surface_swapchain_create --> + <type bitvalues="XrAndroidSurfaceSwapchainFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrAndroidSurfaceSwapchainFlagsFB</name>;</type> + + <!-- Bitmask types for XR_FB_composition_layer_image_layout --> + <type bitvalues="XrCompositionLayerImageLayoutFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrCompositionLayerImageLayoutFlagsFB</name>;</type> + + <!-- Bitmask types for XR_FB_composition_layer_secure_content --> + <type bitvalues="XrCompositionLayerSecureContentFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrCompositionLayerSecureContentFlagsFB</name>;</type> + + <!-- Bitmask types for XR_FB_foveation --> + <type bitvalues="XrSwapchainCreateFoveationFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrSwapchainCreateFoveationFlagsFB</name>;</type> + <type bitvalues="XrSwapchainStateFoveationFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrSwapchainStateFoveationFlagsFB</name>;</type> + + <!-- Bitmask types for XR_META_foveation_eye_tracked --> + <type bitvalues="XrFoveationEyeTrackedProfileCreateFlagBitsMETA" category="bitmask">typedef <type>XrFlags64</type> <name>XrFoveationEyeTrackedProfileCreateFlagsMETA</name>;</type> + <type bitvalues="XrFoveationEyeTrackedStateFlagBitsMETA" category="bitmask">typedef <type>XrFlags64</type> <name>XrFoveationEyeTrackedStateFlagsMETA</name>;</type> + + <!-- Bitmask types for XR_FB_triangle_mesh --> + <type bitvalues="XrTriangleMeshFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrTriangleMeshFlagsFB</name>;</type> + + <!-- Bitmask types for XR_FB_passthrough --> + <type bitvalues="XrPassthroughFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrPassthroughFlagsFB</name>;</type> + <type bitvalues="XrPassthroughStateChangedFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrPassthroughStateChangedFlagsFB</name>;</type> + <type bitvalues="XrPassthroughCapabilityFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrPassthroughCapabilityFlagsFB</name>;</type> + + <!-- Bitmask types for XR_FB_scene --> + <type bitvalues="XrSemanticLabelsSupportFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrSemanticLabelsSupportFlagsFB</name>;</type> + + <!-- Bitmask types for XR_FB_hand_tracking_aim --> + <type bitvalues="XrHandTrackingAimFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrHandTrackingAimFlagsFB</name>;</type> + + <!-- Bitmask types for XR_BD_body_tracking_auxiliary_metrics --> + <type bitvalues="XrSpaceAccelerationFlagBitsBD" category="bitmask">typedef <type>XrFlags64</type> <name>XrSpaceAccelerationFlagsBD</name>;</type> + + <!-- Bitmask types for XR_FB_keyboard_tracking --> + <type bitvalues="XrKeyboardTrackingFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrKeyboardTrackingFlagsFB</name>;</type> + <type bitvalues="XrKeyboardTrackingQueryFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrKeyboardTrackingQueryFlagsFB</name>;</type> + + <!-- Bitmask types for XR_FB_space_warp --> + <type bitvalues="XrCompositionLayerSpaceWarpInfoFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrCompositionLayerSpaceWarpInfoFlagsFB</name>;</type> + + <!-- Bitmask types for XR_FB_render_model --> + <type bitvalues="XrRenderModelFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrRenderModelFlagsFB</name>;</type> + + <!-- Bitmask types for XR_ALMALENCE_digital_lens_control --> + <type bitvalues="XrDigitalLensControlFlagBitsALMALENCE" category="bitmask">typedef <type>XrFlags64</type> <name>XrDigitalLensControlFlagsALMALENCE</name>;</type> + + <!-- Bitmask types for XR_FB_composition_layer_settings --> + <type bitvalues="XrCompositionLayerSettingsFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrCompositionLayerSettingsFlagsFB</name>;</type> + + <!-- Bitmask types for XR_OCULUS_external_camera --> + <type bitvalues="XrExternalCameraStatusFlagBitsOCULUS" category="bitmask">typedef <type>XrFlags64</type> <name>XrExternalCameraStatusFlagsOCULUS</name>;</type> + + <!-- Bitmask types for XR_META_performance_metrics --> + <type bitvalues="XrPerformanceMetricsCounterFlagBitsMETA" category="bitmask">typedef <type>XrFlags64</type> <name>XrPerformanceMetricsCounterFlagsMETA</name>;</type> + + <!-- Bitmask types for XR_META_passthrough_preferences --> + <type bitvalues="XrPassthroughPreferenceFlagBitsMETA" category="bitmask">typedef <type>XrFlags64</type> <name>XrPassthroughPreferenceFlagsMETA</name>;</type> + + <!-- Bitmask types for XR_HTC_foveation --> + <type bitvalues="XrFoveationDynamicFlagBitsHTC" category="bitmask">typedef <type>XrFlags64</type> <name>XrFoveationDynamicFlagsHTC</name>;</type> + + <!-- enums for XR_ANDROID_passthrough_camera_state --> + <type name="XrPassthroughCameraStateANDROID" category="enum"/> + + <!-- Bitmask types for XR_ANDROID_performance_metrics --> + <type bitvalues="XrPerformanceMetricsCounterFlagBitsANDROID" category="bitmask">typedef <type>XrFlags64</type> <name>XrPerformanceMetricsCounterFlagsANDROID</name>;</type> + + <!-- Bitmask types for XR_ML_frame_end_info --> + <type bitvalues="XrFrameEndInfoFlagBitsML" category="bitmask">typedef <type>XrFlags64</type> <name>XrFrameEndInfoFlagsML</name>;</type> + + <!-- Bitmask types for XR_ML_global_dimmer --> + <type bitvalues="XrGlobalDimmerFrameEndInfoFlagBitsML" category="bitmask">typedef <type>XrFlags64</type> <name>XrGlobalDimmerFrameEndInfoFlagsML</name>;</type> + + <!-- Bitmask types for XR_EXT_plane_detection --> + <type bitvalues="XrPlaneDetectorFlagBitsEXT" category="bitmask">typedef <type>XrFlags64</type> <name>XrPlaneDetectorFlagsEXT</name>;</type> + <type bitvalues="XrPlaneDetectionCapabilityFlagBitsEXT" category="bitmask">typedef <type>XrFlags64</type> <name>XrPlaneDetectionCapabilityFlagsEXT</name>;</type> + + <!-- Bitmask types for XR_META_virtual_keyboard --> + <type bitvalues="XrVirtualKeyboardInputStateFlagBitsMETA" category="bitmask">typedef <type>XrFlags64</type> <name>XrVirtualKeyboardInputStateFlagsMETA</name>;</type> + + <!-- Bitmask types for XR_ML_localization_map --> + <type bitvalues="XrLocalizationMapErrorFlagBitsML" category="bitmask">typedef <type>XrFlags64</type> <name>XrLocalizationMapErrorFlagsML</name>;</type> + + <!-- Bitmask types for XR_META_environment_depth --> + <type bitvalues="XrEnvironmentDepthProviderCreateFlagBitsMETA" category="bitmask">typedef <type>XrFlags64</type> <name>XrEnvironmentDepthProviderCreateFlagsMETA</name>;</type> + <type bitvalues="XrEnvironmentDepthSwapchainCreateFlagBitsMETA" category="bitmask">typedef <type>XrFlags64</type> <name>XrEnvironmentDepthSwapchainCreateFlagsMETA</name>;</type> + + <!-- XR_ML_world_mesh_detection --> + <type bitvalues="XrWorldMeshDetectorFlagBitsML" category="bitmask">typedef <type>XrFlags64</type> <name>XrWorldMeshDetectorFlagsML</name>;</type> + + <!-- XR_BD_spatial_audio_rendering --> + <type bitvalues="XrSoundObstacleFlagBitsBD" category="bitmask">typedef <type>XrFlags64</type> <name>XrSoundObstacleFlagsBD</name>;</type> + <type bitvalues="XrSoundObjectFlagBitsBD" category="bitmask">typedef <type>XrFlags64</type> <name>XrSoundObjectFlagsBD</name>;</type> + <type bitvalues="XrSoundFieldFlagBitsBD" category="bitmask">typedef <type>XrFlags64</type> <name>XrSoundFieldFlagsBD</name>;</type> + + <!-- Bitmask types for XR_ML_facial_expression --> + <type bitvalues="XrFacialExpressionBlendShapePropertiesFlagBitsML" category="bitmask">typedef <type>XrFlags64</type> <name>XrFacialExpressionBlendShapePropertiesFlagsML</name>;</type> + + <!-- Bitmask types for XR_BD_spatial_mesh --> + <type bitvalues="XrSpatialMeshConfigFlagBitsBD" category="bitmask">typedef <type>XrFlags64</type> <name>XrSpatialMeshConfigFlagsBD</name>;</type> + + <!-- Bitmask types for XR_ANDROID_geospatial --> + <type bitvalues="XrGeospatialPoseFlagBitsANDROID" category="bitmask">typedef <type>XrFlags64</type> <name>XrGeospatialPoseFlagsANDROID</name>;</type> + + <!-- Bitmask types for XR_BD_spatial_light_estimation --> + <type bitvalues="XrLightEstimationCreateFlagBitsBD" category="bitmask">typedef <type>XrFlags64</type> <name>XrLightEstimationCreateFlagsBD</name>;</type> + + + <!-- Handles referring to internally-maintained objects. --> + <!-- These types which can be 64-bit integers or opaque pointers, selected at compile time based on pointer size --> + <type category="handle"><type>XR_DEFINE_HANDLE</type>(<name>XrInstance</name>)</type> + <type category="handle" parent="XrInstance"><type>XR_DEFINE_HANDLE</type>(<name>XrSession</name>)</type> + <type category="handle" parent="XrInstance"><type>XR_DEFINE_HANDLE</type>(<name>XrActionSet</name>)</type> + <type category="handle" parent="XrActionSet"><type>XR_DEFINE_HANDLE</type>(<name>XrAction</name>)</type> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSwapchain</name>)</type> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSpace</name>)</type> + + <!-- XR_EXT_debug_utils --> + <type category="handle" parent="XrInstance"><type>XR_DEFINE_HANDLE</type>(<name>XrDebugUtilsMessengerEXT</name>)</type> + + <!-- XR_MSFT_spatial_anchor --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSpatialAnchorMSFT</name>)</type> + + <!-- XR_EXT_hand_tracking --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrHandTrackerEXT</name>)</type> + + <!-- XR_FB_foveation --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrFoveationProfileFB</name>)</type> + + <!-- XR_FB_triangle_mesh --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrTriangleMeshFB</name>)</type> + + <!-- XR_FB_passthrough --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrPassthroughFB</name>)</type> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrPassthroughLayerFB</name>)</type> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrGeometryInstanceFB</name>)</type> + + <!-- XR_HTC_facial_tracking --> + <type category="handle" parent="XrInstance"><type>XR_DEFINE_HANDLE</type>(<name>XrFacialTrackerHTC</name>)</type> + + <!-- XR_HTC_passthrough --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrPassthroughHTC</name>)</type> + + <!-- XR_ANDROID_face_tracking --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrFaceTrackerANDROID</name>)</type> + + <!-- XR_ANDROID_trackables_marker --> + <type name="XrTrackableMarkerTrackingModeANDROID" category="enum"/> + <type name="XrTrackableMarkerDictionaryANDROID" category="enum"/> + + <!-- XR_ANDROID_device_anchor_persistence --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrDeviceAnchorPersistenceANDROID</name>)</type> + + <!-- XR_ANDROID_composition_layer_passthrough_mesh --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrPassthroughLayerANDROID</name>)</type> + + <!-- XR_ANDROID_scene_meshing --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSceneMeshingTrackerANDROID</name>)</type> + <type category="handle" parent="XrSceneMeshingTrackerANDROID"><type>XR_DEFINE_HANDLE</type>(<name>XrSceneMeshSnapshotANDROID</name>)</type> + + <!-- XR_ANDROID_eye_tracking --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrEyeTrackerANDROID</name>)</type> + + <!-- XR_ANDROID_light_estimation --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrLightEstimatorANDROID</name>)</type> + + <!-- XR_FB_face_tracking --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrFaceTrackerFB</name>)</type> + + <!-- XR_FB_face_tracking2 --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrFaceTracker2FB</name>)</type> + + <!-- XR_FB_body_tracking --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrBodyTrackerFB</name>)</type> + + <!-- XR_FB_eye_tracking_social --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrEyeTrackerFB</name>)</type> + + <!-- XR_FB_spatial_entity_user --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSpaceUserFB</name>)</type> + + <!-- XR_META_passthrough_color_lut --> + <type category="handle" parent="XrPassthroughFB"><type>XR_DEFINE_HANDLE</type>(<name>XrPassthroughColorLutMETA</name>)</type> + + <!-- XR_EXT_plane_detection --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrPlaneDetectorEXT</name>)</type> + + <!-- XR_META_virtual_keyboard --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrVirtualKeyboardMETA</name>)</type> + + <!-- XR_ML_spatial_anchors_storage --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSpatialAnchorsStorageML</name>)</type> + + <!-- XR_ML_localization_map --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrExportedLocalizationMapML</name>)</type> + + <!-- XR_ML_marker_understanding --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrMarkerDetectorML</name>)</type> + + <!-- XR_ML_facial_expression --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrFacialExpressionClientML</name>)</type> + + <!-- XR_META_environment_depth --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrEnvironmentDepthProviderMETA</name>)</type> + <type category="handle" parent="XrEnvironmentDepthProviderMETA"><type>XR_DEFINE_HANDLE</type>(<name>XrEnvironmentDepthSwapchainMETA</name>)</type> + + <!-- XR_EXT_spatial_entity --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSpatialContextEXT</name>)</type> + <type category="handle" parent="XrSpatialContextEXT"><type>XR_DEFINE_HANDLE</type>(<name>XrSpatialEntityEXT</name>)</type> + <type category="handle" parent="XrSpatialContextEXT"><type>XR_DEFINE_HANDLE</type>(<name>XrSpatialSnapshotEXT</name>)</type> + + <!-- XR_EXT_spatial_persistence --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSpatialPersistenceContextEXT</name>)</type> + + <!-- XR_HTC_body_tracking --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrBodyTrackerHTC</name>)</type> + + <!-- XR_ML_world_mesh_detection --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrWorldMeshDetectorML</name>)</type> + + <!-- XR_BD_spatial_audio_rendering --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSpatialAudioRendererBD</name>)</type> + <type category="handle" parent="XrSpatialAudioRendererBD"><type>XR_DEFINE_HANDLE</type>(<name>XrSoundFieldBD</name>)</type> + <type category="handle" parent="XrSpatialAudioRendererBD"><type>XR_DEFINE_HANDLE</type>(<name>XrSoundObjectBD</name>)</type> + <type category="handle" parent="XrSpatialAudioRendererBD"><type>XR_DEFINE_HANDLE</type>(<name>XrSoundObstacleBD</name>)</type> + <type category="handle" parent="XrSpatialAudioRendererBD"><type>XR_DEFINE_HANDLE</type>(<name>XrSoundObstacleMaterialBD</name>)</type> + + <!-- XR_BD_body_tracking --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrBodyTrackerBD</name>)</type> + + <!-- XR_EXT_render_model --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrRenderModelEXT</name>)</type> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrRenderModelAssetEXT</name>)</type> + + <!-- XR_BD_spatial_sensing --> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrSpatialEntityIdBD</name>)</type> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSenseDataProviderBD</name>)</type> + <type category="handle" parent="XrSenseDataProviderBD"><type>XR_DEFINE_HANDLE</type>(<name>XrSenseDataSnapshotBD</name>)</type> + <type category="handle" parent="XrSenseDataProviderBD"><type>XR_DEFINE_HANDLE</type>(<name>XrAnchorBD</name>)</type> + + <!-- XR_BD_facial_simulation --> + <type category="handle" parent="XrSession"> <type>XR_DEFINE_HANDLE</type>(<name>XrFaceTrackerBD</name>)</type> + + <!-- XR_META_environment_raycast --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrEnvironmentRaycasterMETA</name>)</type> + + <!-- XR_ANDROID_geospatial --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrGeospatialTrackerANDROID</name>)</type> + + <!-- XR_BD_camera_image --> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrCameraIdBD</name>)</type> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrCameraImageIdBD</name>)</type> + <type category="handle" parent="XrInstance"><type>XR_DEFINE_HANDLE</type>(<name>XrCameraDeviceBD</name>)</type> + <type category="handle" parent="XrCameraDeviceBD"><type>XR_DEFINE_HANDLE</type>(<name>XrCameraCaptureSessionBD</name>)</type> + + + <!-- Non-handle 64-bit opaque type from XR_EXT_future --> + <type category="basetype"><type>XR_DEFINE_OPAQUE_64</type>(<name>XrFutureEXT</name>)</type> + + + <!-- enums and flag bits generated from corresponding <enums> tags below --> + <type name="XrLoaderInterfaceStructs" category="enum"/> + <type name="XrStructureType" category="enum"/> + <type name="XrResult" category="enum"/> + <type name="XrObjectType" category="enum"/> + <type name="XrInstanceCreateFlagBits" category="enum"/> + <type name="XrSessionCreateFlagBits" category="enum"/> + <type name="XrSwapchainCreateFlagBits" category="enum"/> + <type name="XrSwapchainUsageFlagBits" category="enum"/> + <type name="XrViewStateFlagBits" category="enum"/> + <type name="XrCompositionLayerFlagBits" category="enum"/> + <type name="XrSpaceLocationFlagBits" category="enum"/> + <type name="XrSpaceVelocityFlagBits" category="enum"/> + <type name="XrInputSourceLocalizedNameFlagBits" category="enum"/> + <type name="XrAndroidThreadTypeKHR" category="enum"/> + <type name="XrEyeVisibility" category="enum"/> + <type name="XrActionType" category="enum"/> + <type name="XrReferenceSpaceType" category="enum"/> + <type name="XrFormFactor" category="enum"/> + <type name="XrViewConfigurationType" category="enum"/> + <type name="XrEnvironmentBlendMode" category="enum"/> + <type name="XrSessionState" category="enum"/> + <type name="XrPerfSettingsDomainEXT" category="enum"/> + <type name="XrPerfSettingsSubDomainEXT" category="enum"/> + <type name="XrPerfSettingsLevelEXT" category="enum"/> + <type name="XrPerfSettingsNotificationLevelEXT" category="enum"/> + + <!-- flag bits for XR_KHR_vulkan_enable2 --> + <type name="XrVulkanInstanceCreateFlagBitsKHR" category="enum"/> + <type name="XrVulkanDeviceCreateFlagBitsKHR" category="enum"/> + + <!-- flag bits for XR_EXT_debug_utils --> + <type name="XrDebugUtilsMessageSeverityFlagBitsEXT" category="enum"/> + <type name="XrDebugUtilsMessageTypeFlagBitsEXT" category="enum"/> + + <!-- flag bits for XR_EXT_frame_synthesis --> + <type name="XrFrameSynthesisInfoFlagBitsEXT" category="enum"/> + + <!-- flag bits for XR_EXTX_overlay --> + <type name="XrOverlayMainSessionFlagBitsEXTX" category="enum"/> + <type name="XrOverlaySessionCreateFlagBitsEXTX" category="enum"/> + + <!-- enums for XR_KHR_visibility_mask --> + <type name="XrVisibilityMaskTypeKHR" category="enum"/> + + <!-- enums for XR_MSFT_spatial_graph_bridge --> + <type name="XrSpatialGraphNodeTypeMSFT" category="enum"/> + + <!-- flag bits for XR_FB_android_surface_swapchain_create --> + <type name="XrAndroidSurfaceSwapchainFlagBitsFB" category="enum"/> + + <!-- flag bits for XR_FB_composition_layer_image_layout --> + <type name="XrCompositionLayerImageLayoutFlagBitsFB" category="enum"/> + + <!-- enums for XR_FB_composition_layer_alpha_blend --> + <type name="XrBlendFactorFB" category="enum"/> + + <!-- flag bits for XR_FB_composition_layer_secure_content --> + <type name="XrCompositionLayerSecureContentFlagBitsFB" category="enum"/> + + <!-- enums for XR_FB_spatial_entity --> + <type name="XrSpaceComponentTypeFB" category="enum"/> + + <!-- flag bits for XR_FB_foveation --> + <type name="XrSwapchainCreateFoveationFlagBitsFB" category="enum"/> + <type name="XrSwapchainStateFoveationFlagBitsFB" category="enum"/> + + <!-- flag bits for XR_META_foveation_eye_tracked --> + <type name="XrFoveationEyeTrackedProfileCreateFlagBitsMETA" category="enum"/> + <type name="XrFoveationEyeTrackedStateFlagBitsMETA" category="enum"/> + + <!-- enums and flag bits for XR_FB_triangle_mesh --> + <type name="XrTriangleMeshFlagBitsFB" category="enum"/> + <type name="XrWindingOrderFB" category="enum"/> + + <!-- enums and flag bits for XR_FB_passthrough --> + <type name="XrPassthroughFlagBitsFB" category="enum"/> + <type name="XrPassthroughLayerPurposeFB" category="enum"/> + <type name="XrPassthroughStateChangedFlagBitsFB" category="enum"/> + <type name="XrPassthroughCapabilityFlagBitsFB" category="enum"/> + + <!-- flag bits for XR_FB_space_warp --> + <type name="XrCompositionLayerSpaceWarpInfoFlagBitsFB" category="enum"/> + + <!-- flag bits for XR_FB_render_model --> + <type name="XrRenderModelFlagBitsFB" category="enum"/> + + <!-- enums for XR_FB_spatial_entity_query --> + <type name="XrSpaceQueryActionFB" category="enum"/> + + <!-- enums for XR_FB_spatial_entity_storage --> + <type name="XrSpaceStorageLocationFB" category="enum"/> + <type name="XrSpacePersistenceModeFB" category="enum"/> + + <!-- enums for XR_META_spatial_entity_semantic_label --> + <type name="XrSemanticLabelMETA" category="enum"/> + + <!-- enums for XR_META_boundary_visibility --> + <type name="XrBoundaryVisibilityMETA" category="enum"/> + + <!-- flag bits for XR_FB_scene --> + <type name="XrSemanticLabelsSupportFlagBitsFB" category="enum"/> + + <!-- flag bits for XR_FB_hand_tracking_aim --> + <type name="XrHandTrackingAimFlagBitsFB" category="enum"/> + + <!-- flag bits for XR_BD_body_tracking_auxiliary_metrics --> + <type name="XrSpaceAccelerationFlagBitsBD" category="enum"/> + + <!-- flag bits for XR_FB_keyboard_tracking --> + <type name="XrKeyboardTrackingFlagBitsFB" category="enum"/> + <type name="XrKeyboardTrackingQueryFlagBitsFB" category="enum"/> + + <!-- flag bits for XR_ALMALENCE_digital_lens_control --> + <type name="XrDigitalLensControlFlagBitsALMALENCE" category="enum"/> + + <!-- flag bits for XR_FB_composition_layer_settings --> + <type name="XrCompositionLayerSettingsFlagBitsFB" category="enum"/> + + <!-- enum and flag bits for XR_OCULUS_external_camera --> + <type name="XrExternalCameraStatusFlagBitsOCULUS" category="enum"/> + <type name="XrExternalCameraAttachedToDeviceOCULUS" category="enum"/> + + <!-- enums for XR_META_passthrough_color_lut --> + <type name="XrPassthroughColorLutChannelsMETA" category="enum"/> + + <!-- enum and flag bits for XR_META_performance_metrics --> + <type name="XrPerformanceMetricsCounterFlagBitsMETA" category="enum"/> + <type name="XrPerformanceMetricsCounterUnitMETA" category="enum"/> + + <!-- enum and flag bits for XR_META_passthrough_preferences --> + <type name="XrPassthroughPreferenceFlagBitsMETA" category="enum"/> + + <!-- XR_HTC_facial_tracking --> + <type name="XrFacialTrackingTypeHTC" category="enum"/> + <type name="XrEyeExpressionHTC" category="enum"/> + <type name="XrLipExpressionHTC" category="enum"/> + + <!-- enum for XR_HTC_passthrough --> + <type name="XrPassthroughFormHTC" category="enum"/> + + <!-- enums for XR_HTC_foveation --> + <type name="XrFoveationModeHTC" category="enum"/> + <type name="XrFoveationDynamicFlagBitsHTC" category="enum"/> + <type name="XrFoveationLevelHTC" category="enum"/> + + <!-- enums for XR_ANDROID_face_tracking --> + <type name="XrFaceParameterIndicesANDROID" category="enum"/> + <type name="XrFaceTrackingStateANDROID" category="enum"/> + <type name="XrFaceConfidenceRegionsANDROID" category="enum"/> + + <!-- XR_ANDROID_trackables_object --> + <type name="XrObjectLabelANDROID" category="enum"/> + + <!-- XR_ANDROID_device_anchor_persistence --> + <type name="XrAnchorPersistStateANDROID" category="enum"/> + + <!-- enum and flag bits for XR_ANDROID_performance_metrics --> + <type name="XrPerformanceMetricsCounterUnitANDROID" category="enum"/> + <type name="XrPerformanceMetricsCounterFlagBitsANDROID" category="enum"/> + + <!-- XR_ANDROID_trackables_qr_code --> + <type name="XrQrCodeTrackingModeANDROID" category="enum"/> + + <!-- XR_ANDROID_composition_layer_passthrough_mesh --> + <type name="XrWindingOrderANDROID" category="enum"/> + + <!-- XR_ANDROID_scene_meshing --> + <type name="XrSceneMeshSemanticLabelSetANDROID" category="enum"/> + <type name="XrSceneMeshSemanticLabelANDROID" category="enum"/> + <type name="XrSceneMeshTrackingStateANDROID" category="enum"/> + + <!-- enums for XR_ANDROID_eye_tracking --> + <type name="XrEyeIndexANDROID" category="enum"/> + <type name="XrEyeStateANDROID" category="enum"/> + <type name="XrEyeTrackingModeANDROID" category="enum"/> + + <!-- XR_ANDROID_light_estimation --> + <type name="XrSphericalHarmonicsKindANDROID" category="enum"/> + <type name="XrLightEstimateStateANDROID" category="enum"/> + + <!-- XR_META_local_dimming --> + <type name="XrLocalDimmingModeMETA" category="enum"/> + + <!-- enums for XR_FB_face_tracking --> + <type name="XrFaceExpressionFB" category="enum"/> + <type name="XrFaceExpressionSetFB" category="enum"/> + <type name="XrFaceConfidenceFB" category="enum"/> + + <!-- enums for XR_FB_face_tracking2 --> + <type name="XrFaceExpression2FB" category="enum"/> + <type name="XrFaceExpressionSet2FB" category="enum"/> + <type name="XrFaceTrackingDataSource2FB" category="enum"/> + <type name="XrFaceConfidence2FB" category="enum"/> + + <!-- enums for XR_META_face_tracking_visemes --> + <type name="XrFaceTrackingVisemeMETA" category="enum"/> + + <!-- enums for XR_FB_body_tracking --> + <type name="XrBodyJointFB" category="enum"/> + <type name="XrBodyJointSetFB" category="enum"/> + + <!-- enums for XR_META_body_tracking_full_body --> + <type name="XrFullBodyJointMETA" category="enum"/> + + <!-- enums for XR_META_body_tracking_calibration --> + <type name="XrBodyTrackingCalibrationStateMETA" category="enum"/> + + <!-- enums for XR_META_body_tracking_fidelity --> + <type name="XrBodyTrackingFidelityMETA" category="enum" comment="Fidelity options for body tracking expression. The application can: request a desired fidelity, and the runtime will attempt to use that fidelity to provide body tracking for this application."/> + + <!-- enum for XR_ML_frame_end_info --> + <type name="XrFrameEndInfoFlagBitsML" category="enum"/> + + <!-- enums for XR_FB_eye_tracking_social --> + <type name="XrEyePositionFB" category="enum"/> + + <!-- enums for XR_ML_global_dimmer --> + <type name="XrGlobalDimmerFrameEndInfoFlagBitsML" category="enum"/> + + <!-- enums for XR_QCOM_tracking_optimization_settings --> + <type name="XrTrackingOptimizationSettingsDomainQCOM" category="enum"/> + <type name="XrTrackingOptimizationSettingsHintQCOM" category="enum"/> + + <!-- XR_MNDX_force_feedback_curl --> + <type name="XrForceFeedbackCurlLocationMNDX" category="enum"/> + + <!-- enums for XR_EXT_plane_detection --> + <type name="XrPlaneDetectionStateEXT" category="enum"/> + <type name="XrPlaneDetectorOrientationEXT" category="enum"/> + <type name="XrPlaneDetectorSemanticTypeEXT" category="enum"/> + <type name="XrPlaneDetectorFlagBitsEXT" category="enum"/> + <type name="XrPlaneDetectionCapabilityFlagBitsEXT" category="enum"/> + + <!-- enums for XR_META_virtual_keyboard --> + <type name="XrVirtualKeyboardLocationTypeMETA" category="enum"/> + <type name="XrVirtualKeyboardInputSourceMETA" category="enum"/> + <type name="XrVirtualKeyboardInputStateFlagBitsMETA" category="enum"/> + + <!-- enums for XR_ML_user_calibration --> + <type name="XrHeadsetFitStatusML" category="enum"/> + <type name="XrEyeCalibrationStatusML" category="enum"/> + + <!-- XR_ML_localization_map --> + <type name="XrLocalizationMapStateML" category="enum"/> + <type name="XrLocalizationMapTypeML" category="enum"/> + <type name="XrLocalizationMapConfidenceML" category="enum"/> + <type name="XrLocalizationMapErrorFlagBitsML" category="enum"/> + + <!-- XR_ML_marker_understanding --> + <type name="XrMarkerDetectorProfileML" category="enum"/> + <type name="XrMarkerTypeML" category="enum"/> + <type name="XrMarkerArucoDictML" category="enum"/> + <type name="XrMarkerAprilTagDictML" category="enum"/> + <type name="XrMarkerDetectorFpsML" category="enum"/> + <type name="XrMarkerDetectorResolutionML" category="enum"/> + <type name="XrMarkerDetectorCameraML" category="enum"/> + <type name="XrMarkerDetectorCornerRefineMethodML" category="enum"/> + <type name="XrMarkerDetectorFullAnalysisIntervalML" category="enum"/> + <type name="XrMarkerDetectorStatusML" category="enum"/> + + <!-- enums for XR_ML_facial_expression --> + <type name="XrFacialBlendShapeML" category="enum"/> + <type name="XrFacialExpressionBlendShapePropertiesFlagBitsML" category="enum"/> + + <!-- XR_EXT_future --> + <type name="XrFutureStateEXT" category="enum"/> + + <!-- XR_META_environment_depth --> + <type name="XrEnvironmentDepthProviderCreateFlagBitsMETA" category="enum"/> + <type name="XrEnvironmentDepthSwapchainCreateFlagBitsMETA" category="enum"/> + + <!-- XR_EXT_spatial_entity --> + <type name="XrSpatialCapabilityEXT" category="enum"/> + <type name="XrSpatialCapabilityFeatureEXT" category="enum"/> + <type name="XrSpatialComponentTypeEXT" category="enum"/> + <type name="XrSpatialEntityTrackingStateEXT" category="enum"/> + <type name="XrSpatialBufferTypeEXT" category="enum"/> + + <!-- enums for XR_EXT_spatial_persistence --> + <type name="XrSpatialPersistenceScopeEXT" category="enum"/> + <type name="XrSpatialPersistenceContextResultEXT" category="enum"/> + <type name="XrSpatialPersistenceStateEXT" category="enum"/> + + <!-- enums for XR_EXT_spatial_plane_tracking --> + <type name="XrSpatialPlaneAlignmentEXT" category="enum"/> + <type name="XrSpatialPlaneSemanticLabelEXT" category="enum"/> + + <!-- XR_HTC_body_tracking --> + <type name="XrBodyJointHTC" category="enum"/> + <type name="XrBodyJointSetHTC" category="enum"/> + <type name="XrBodyJointConfidenceHTC" category="enum"/> + + <!-- XR_ML_spatial_anchors --> + <type name="XrSpatialAnchorConfidenceML" category="enum"/> + + <!-- XR_ML_world_mesh_detection --> + <type name="XrWorldMeshBlockStatusML" category="enum"/> + <type name="XrWorldMeshDetectorFlagBitsML" category="enum"/> + <type name="XrWorldMeshDetectorLodML" category="enum"/> + <type name="XrWorldMeshBlockResultML" category="enum"/> + + <!-- XR_BD_body_tracking --> + <type name="XrBodyJointBD" category="enum"/> + <type name="XrBodyJointSetBD" category="enum"/> + + <!-- XR_BD_spatial_audio_rendering --> + <type name="XrAudioSampleRateBD" category="enum"/> + <type name="XrAudioBufferChannelLayoutBD" category="enum"/> + <type name="XrSoundObstacleMaterialTypeBD" category="enum"/> + <type name="XrSoundObstacleFlagBitsBD" category="enum"/> + <type name="XrSoundObjectDistanceAttenuationTypeBD" category="enum"/> + <type name="XrSoundObjectFlagBitsBD" category="enum"/> + <type name="XrSoundFieldChannelMaskSurroundBD" category="enum"/> + <type name="XrSoundFieldChannelMaskAmbixBD" category="enum"/> + <type name="XrSoundFieldChannelMaskFumaBD" category="enum"/> + <type name="XrSoundFieldFlagBitsBD" category="enum"/> + + <!-- enums for XR_BD_spatial_sensing --> + <type name="XrSenseDataProviderTypeBD" category="enum"/> + <type name="XrSemanticLabelBD" category="enum"/> + <type name="XrSpatialEntityComponentTypeBD" category="enum"/> + <type name="XrSenseDataProviderStateBD" category="enum"/> + + <!-- enums for XR_BD_spatial_anchor --> + <type name="XrPersistenceLocationBD" category="enum"/> + + <!-- enums for XR_BD_spatial_mesh --> + <type name="XrSpatialMeshLodBD" category="enum"/> + <type name="XrSpatialMeshConfigFlagBitsBD" category="enum"/> + + <!-- enums for XR_BD_spatial_plane --> + <type name="XrPlaneOrientationBD" category="enum"/> + + <!-- enums for XR_BD_spatial_light_estimation --> + <type name="XrEnvironmentTextureResolutionBD" category="enum"/> + <type name="XrEnvironmentTextureTransferTypeBD" category="enum"/> + <type name="XrEnvironmentTexturePixelFormatBD" category="enum"/> + <type name="XrSphericalHarmonicsKindBD" category="enum"/> + <type name="XrLightEstimationCreateFlagBitsBD" category="enum"/> + + <!-- enums for XR_BD_dynamic_object_tracking --> + <type name="XrDynamicObjectTypeBD" category="enum"/> + + <!-- enums for XR_EXT_spatial_marker_tracking --> + <type name="XrSpatialMarkerArucoDictEXT" category="enum"/> + <type name="XrSpatialMarkerAprilTagDictEXT" category="enum"/> + + <!-- XR_BD_facial_simulation --> + <type name="XrFacialSimulationModeBD" category="enum"/> + <type name="XrFaceExpressionBD" category="enum"/> + <type name="XrLipExpressionBD" category="enum"/> + + <!-- enums for XR_ANDROID_spatial_object_tracking --> + <type name="XrSpatialObjectSemanticLabelANDROID" category="enum"/> + + <!-- XR_META_environment_raycast --> + <type name="XrEnvironmentRaycastHitStatusMETA" category="enum"/> + + <!-- XR_QCOM_hand_tracking_gesture --> + <type name="XrHandGestureTypeQCOM" category="enum"/> + + <!-- XR_EXT_haptic_parametric --> + <type name="XrHapticParametricStreamFrameTypeEXT" category="enum"/> + + <!-- XR_BD_body_tracking_auxiliary_metrics --> + <type name="XrBodyTrackingPostureBD" category="enum"/> + <type name="XrBodyTrackingStatusBD" category="enum"/> + <type name="XrBodyTrackingMessageBD" category="enum"/> + + <!-- XR_SONY_swapchain_color_space --> + <type name="XrColorSpaceSONY" category="enum"/> + + <!-- enums for XR_BD_camera_image --> + <type name="XrCameraPropertyTypeBD" category="enum"/> + <type name="XrCameraFacingBD" category="enum"/> + <type name="XrCameraPositionBD" category="enum"/> + <type name="XrCameraTypeBD" category="enum"/> + <type name="XrCameraCapabilityTypeBD" category="enum"/> + <type name="XrCameraDataTransferTypeBD" category="enum"/> + <type name="XrCameraImageFormatBD" category="enum"/> + <type name="XrCameraModelBD" category="enum"/> + + <!-- Struct types --> + <type category="struct" name="XrVector2f"> + <member><type>float</type> <name>x</name></member> + <member><type>float</type> <name>y</name></member> + </type> + <type category="struct" name="XrVector3f"> + <member><type>float</type> <name>x</name></member> + <member><type>float</type> <name>y</name></member> + <member><type>float</type> <name>z</name></member> + </type> + <type category="struct" name="XrVector4f"> + <member><type>float</type> <name>x</name></member> + <member><type>float</type> <name>y</name></member> + <member><type>float</type> <name>z</name></member> + <member><type>float</type> <name>w</name></member> + </type> + <type category="struct" name="XrColor4f"> + <member><type>float</type> <name>r</name></member> + <member><type>float</type> <name>g</name></member> + <member><type>float</type> <name>b</name></member> + <member><type>float</type> <name>a</name></member> + </type> + <type category="struct" name="XrQuaternionf"> + <member><type>float</type> <name>x</name></member> + <member><type>float</type> <name>y</name></member> + <member><type>float</type> <name>z</name></member> + <member><type>float</type> <name>w</name></member> + </type> + <type category="struct" name="XrPosef"> + <member><type>XrQuaternionf</type> <name>orientation</name></member> + <member><type>XrVector3f</type> <name>position</name></member> + </type> + <type category="struct" name="XrOffset2Df"> + <member><type>float</type> <name>x</name></member> + <member><type>float</type> <name>y</name></member> + </type> + <type category="struct" name="XrExtent2Df"> + <member><type>float</type> <name>width</name></member> + <member><type>float</type> <name>height</name></member> + </type> + + <type category="struct" name="XrExtent3DfEXT" alias="XrExtent3Df"/> + + <type category="struct" name="XrRect2Df"> + <member><type>XrOffset2Df</type> <name>offset</name></member> + <member><type>XrExtent2Df</type> <name>extent</name></member> + </type> + <type category="struct" name="XrOffset2Di"> + <member><type>int32_t</type> <name>x</name></member> + <member><type>int32_t</type> <name>y</name></member> + </type> + <type category="struct" name="XrExtent2Di"> + <member><type>int32_t</type> <name>width</name></member> + <member><type>int32_t</type> <name>height</name></member> + </type> + <type category="struct" name="XrRect2Di"> + <member><type>XrOffset2Di</type> <name>offset</name></member> + <member><type>XrExtent2Di</type> <name>extent</name></member> + </type> + + <!-- openxr_loader_negotiation.h --> + <type category="struct" name="XrNegotiateLoaderInfo"> + <member><type>XrLoaderInterfaceStructs</type> <name>structType</name></member> + <member><type>uint32_t</type> <name>structVersion</name></member> + <member><type>size_t</type> <name>structSize</name></member> + <member><type>uint32_t</type> <name>minInterfaceVersion</name></member> + <member><type>uint32_t</type> <name>maxInterfaceVersion</name></member> + <member><type>XrVersion</type> <name>minApiVersion</name></member> + <member><type>XrVersion</type> <name>maxApiVersion</name></member> + </type> + <type category="struct" name="XrNegotiateApiLayerRequest"> + <member><type>XrLoaderInterfaceStructs</type> <name>structType</name></member> + <member><type>uint32_t</type> <name>structVersion</name></member> + <member><type>size_t</type> <name>structSize</name></member> + <member><type>uint32_t</type> <name>layerInterfaceVersion</name></member> + <member><type>XrVersion</type> <name>layerApiVersion</name></member> + <member><type>PFN_xrGetInstanceProcAddr</type> <name>getInstanceProcAddr</name></member> + <member><type>PFN_xrCreateApiLayerInstance</type> <name>createApiLayerInstance</name></member> + </type> + <type category="struct" name="XrNegotiateRuntimeRequest"> + <member><type>XrLoaderInterfaceStructs</type> <name>structType</name></member> + <member><type>uint32_t</type> <name>structVersion</name></member> + <member><type>size_t</type> <name>structSize</name></member> + <member><type>uint32_t</type> <name>runtimeInterfaceVersion</name></member> + <member><type>XrVersion</type> <name>runtimeApiVersion</name></member> + <member><type>PFN_xrGetInstanceProcAddr</type> <name>getInstanceProcAddr</name></member> + </type> + + <type category="struct" name="XrApiLayerNextInfo"> + <member><type>XrLoaderInterfaceStructs</type> <name>structType</name></member> + <member><type>uint32_t</type> <name>structVersion</name></member> + <member><type>size_t</type> <name>structSize</name></member> + <member><type>char</type> <name>layerName</name>[<enum>XR_MAX_API_LAYER_NAME_SIZE</enum>]</member> + <member><type>PFN_xrGetInstanceProcAddr</type> <name>nextGetInstanceProcAddr</name></member> + <member><type>PFN_xrCreateApiLayerInstance</type> <name>nextCreateApiLayerInstance</name></member> + <member>struct <type>XrApiLayerNextInfo</type>* <name>next</name></member> + </type> + <type category="struct" name="XrApiLayerCreateInfo"> + <member><type>XrLoaderInterfaceStructs</type> <name>structType</name></member> + <member><type>uint32_t</type> <name>structVersion</name></member> + <member><type>size_t</type> <name>structSize</name></member> + <member><type>void</type>* <name>loaderInstance</name></member> + <member><type>char</type> <name>settings_file_location</name>[XR_API_LAYER_MAX_SETTINGS_PATH_SIZE]</member> + <member><type>XrApiLayerNextInfo</type>* <name>nextInfo</name></member> + </type> + + <comment> + XrBaseInStructure and XrBaseOutStructure use "struct" in their member definitions + because they are recursive structures and this is easier than modifying the tooling + to output forward declarations. + </comment> + <type category="struct" name="XrBaseInStructure" mayalias="true"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const struct <type>XrBaseInStructure</type>* <name>next</name></member> + </type> + <type category="struct" name="XrBaseOutStructure" mayalias="true"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>struct <type>XrBaseOutStructure</type>* <name>next</name></member> + </type> + <type category="struct" name="XrApiLayerProperties" returnedonly="true"> + <member values="XR_TYPE_API_LAYER_PROPERTIES"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>char</type> <name>layerName</name>[<enum>XR_MAX_API_LAYER_NAME_SIZE</enum>]</member> + <member><type>XrVersion</type> <name>specVersion</name></member> + <member><type>uint32_t</type> <name>layerVersion</name></member> + <member><type>char</type> <name>description</name>[<enum>XR_MAX_API_LAYER_DESCRIPTION_SIZE</enum>]</member> + </type> + <type category="struct" name="XrExtensionProperties" returnedonly="true"> + <member values="XR_TYPE_EXTENSION_PROPERTIES"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>char</type> <name>extensionName</name>[<enum>XR_MAX_EXTENSION_NAME_SIZE</enum>]</member> + <member><type>uint32_t</type> <name>extensionVersion</name></member> + </type> + <type category="struct" name="XrApplicationInfo"> + <member><type>char</type> <name>applicationName</name>[<enum>XR_MAX_APPLICATION_NAME_SIZE</enum>]</member> + <member><type>uint32_t</type> <name>applicationVersion</name></member> + <member><type>char</type> <name>engineName</name>[<enum>XR_MAX_ENGINE_NAME_SIZE</enum>]</member> + <member><type>uint32_t</type> <name>engineVersion</name></member> + <member><type>XrVersion</type> <name>apiVersion</name></member> + </type> + <type category="struct" name="XrInstanceCreateInfo"> + <member values="XR_TYPE_INSTANCE_CREATE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrInstanceCreateFlags</type> <name>createFlags</name></member> + <member><type>XrApplicationInfo</type> <name>applicationInfo</name></member> + <member optional="true"><type>uint32_t</type> <name>enabledApiLayerCount</name></member> + <member len="enabledApiLayerCount,null-terminated">const <type>char</type>* const* <name>enabledApiLayerNames</name></member> + <member optional="true"><type>uint32_t</type> <name>enabledExtensionCount</name></member> + <member len="enabledExtensionCount,null-terminated">const <type>char</type>* const* <name>enabledExtensionNames</name></member> + </type> + <type category="struct" name="XrInstanceProperties" returnedonly="true"> + <member values="XR_TYPE_INSTANCE_PROPERTIES"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrVersion</type> <name>runtimeVersion</name></member> + <member><type>char</type> <name>runtimeName</name>[<enum>XR_MAX_RUNTIME_NAME_SIZE</enum>]</member> + </type> + <type category="struct" name="XrSystemGetInfo"> + <member values="XR_TYPE_SYSTEM_GET_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrFormFactor</type> <name>formFactor</name></member> + </type> + <type category="struct" name="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_PROPERTIES"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrSystemId</type> <name>systemId</name></member> + <member><type>uint32_t</type> <name>vendorId</name></member> + <member><type>char</type> <name>systemName</name>[<enum>XR_MAX_SYSTEM_NAME_SIZE</enum>]</member> + <member><type>XrSystemGraphicsProperties</type> <name>graphicsProperties</name></member> + <member><type>XrSystemTrackingProperties</type> <name>trackingProperties</name></member> + </type> + <type category="struct" name="XrSystemGraphicsProperties"> + <member><type>uint32_t</type> <name>maxSwapchainImageHeight</name></member> + <member><type>uint32_t</type> <name>maxSwapchainImageWidth</name></member> + <member><type>uint32_t</type> <name>maxLayerCount</name></member> + </type> + <type category="struct" name="XrSystemTrackingProperties"> + <member><type>XrBool32</type> <name>orientationTracking</name></member> + <member><type>XrBool32</type> <name>positionTracking</name></member> + </type> + <type category="struct" name="XrGraphicsBindingOpenGLWin32KHR" structextends="XrSessionCreateInfo" protect="XR_USE_PLATFORM_WIN32"> + <member values="XR_TYPE_GRAPHICS_BINDING_OPENGL_WIN32_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>HDC</type> <name>hDC</name></member> + <member><type>HGLRC</type> <name>hGLRC</name></member> + </type> + <type category="struct" name="XrGraphicsBindingOpenGLXlibKHR" structextends="XrSessionCreateInfo" protect="XR_USE_PLATFORM_XLIB"> + <member values="XR_TYPE_GRAPHICS_BINDING_OPENGL_XLIB_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>Display</type>* <name>xDisplay</name></member> + <member><type>uint32_t</type> <name>visualid</name></member> + <member><type>GLXFBConfig</type> <name>glxFBConfig</name></member> + <member><type>GLXDrawable</type> <name>glxDrawable</name></member> + <member><type>GLXContext</type> <name>glxContext</name></member> + </type> + <type category="struct" name="XrGraphicsBindingOpenGLXcbKHR" structextends="XrSessionCreateInfo" protect="XR_USE_PLATFORM_XCB"> + <member values="XR_TYPE_GRAPHICS_BINDING_OPENGL_XCB_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>xcb_connection_t</type>* <name>connection</name></member> + <member><type>uint32_t</type> <name>screenNumber</name></member> + <member><type>xcb_glx_fbconfig_t</type> <name>fbconfigid</name></member> + <member><type>xcb_visualid_t</type> <name>visualid</name></member> + <member><type>xcb_glx_drawable_t</type> <name>glxDrawable</name></member> + <member><type>xcb_glx_context_t</type> <name>glxContext</name></member> + </type> + <!-- Deprecated, see Wayland Notes in appendix. --> + <type category="struct" name="XrGraphicsBindingOpenGLWaylandKHR" structextends="XrSessionCreateInfo" protect="XR_USE_PLATFORM_WAYLAND"> + <member values="XR_TYPE_GRAPHICS_BINDING_OPENGL_WAYLAND_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member>struct <type>wl_display</type>* <name>display</name></member> + </type> + <type category="struct" name="XrGraphicsBindingD3D11KHR" structextends="XrSessionCreateInfo"> + <member values="XR_TYPE_GRAPHICS_BINDING_D3D11_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>ID3D11Device</type>* <name>device</name></member> + </type> + <type category="struct" name="XrGraphicsBindingD3D12KHR" structextends="XrSessionCreateInfo"> + <member values="XR_TYPE_GRAPHICS_BINDING_D3D12_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>ID3D12Device</type>* <name>device</name></member> + <member><type>ID3D12CommandQueue</type>* <name>queue</name></member> + </type> + <type category="struct" name="XrGraphicsBindingOpenGLESAndroidKHR" structextends="XrSessionCreateInfo" protect="XR_USE_PLATFORM_ANDROID"> + <member values="XR_TYPE_GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>EGLDisplay</type> <name>display</name></member> + <member><type>EGLConfig</type> <name>config</name></member> + <member><type>EGLContext</type> <name>context</name></member> + </type> + <type category="struct" name="XrGraphicsBindingVulkanKHR" structextends="XrSessionCreateInfo"> + <member values="XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>VkInstance</type> <name>instance</name></member> + <member><type>VkPhysicalDevice</type> <name>physicalDevice</name></member> + <member><type>VkDevice</type> <name>device</name></member> + <member><type>uint32_t</type> <name>queueFamilyIndex</name></member> + <member><type>uint32_t</type> <name>queueIndex</name></member> + </type> + <type category="struct" name="XrGraphicsBindingMetalKHR" structextends="XrSessionCreateInfo"> + <member values="XR_TYPE_GRAPHICS_BINDING_METAL_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>void</type>* <name>commandQueue</name></member> + </type> + <type category="struct" name="XrSessionCreateInfo"> + <member values="XR_TYPE_SESSION_CREATE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrSessionCreateFlags</type> <name>createFlags</name></member> + <member><type>XrSystemId</type> <name>systemId</name></member> + </type> + <type category="struct" name="XrSessionBeginInfo"> + <member values="XR_TYPE_SESSION_BEGIN_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrViewConfigurationType</type> <name>primaryViewConfigurationType</name></member> + </type> + <type category="struct" name="XrSwapchainCreateInfo"> + <member values="XR_TYPE_SWAPCHAIN_CREATE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrSwapchainCreateFlags</type> <name>createFlags</name></member> + <member optional="true"><type>XrSwapchainUsageFlags</type> <name>usageFlags</name></member> + <member><type>int64_t</type> <name>format</name></member> + <member><type>uint32_t</type> <name>sampleCount</name></member> + <member><type>uint32_t</type> <name>width</name></member> + <member><type>uint32_t</type> <name>height</name></member> + <member><type>uint32_t</type> <name>faceCount</name></member> + <member><type>uint32_t</type> <name>arraySize</name></member> + <member><type>uint32_t</type> <name>mipCount</name></member> + </type> + <type category="struct" name="XrSwapchainImageBaseHeader" returnedonly="true"> + <member><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrSwapchainImageOpenGLKHR" parentstruct="XrSwapchainImageBaseHeader" returnedonly="true"> + <member values="XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_KHR"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>image</name></member> + </type> + <type category="struct" name="XrSwapchainImageOpenGLESKHR" parentstruct="XrSwapchainImageBaseHeader" returnedonly="true"> + <member values="XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>image</name></member> + </type> + <type category="struct" name="XrSwapchainImageVulkanKHR" parentstruct="XrSwapchainImageBaseHeader" returnedonly="true"> + <member values="XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>VkImage</type> <name>image</name></member> + </type> + <type category="struct" name="XrSwapchainImageD3D11KHR" parentstruct="XrSwapchainImageBaseHeader" returnedonly="true"> + <member values="XR_TYPE_SWAPCHAIN_IMAGE_D3D11_KHR"> <type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>ID3D11Texture2D</type>* <name>texture</name></member> + </type> + <type category="struct" name="XrSwapchainImageD3D12KHR" parentstruct="XrSwapchainImageBaseHeader" returnedonly="true"> + <member values="XR_TYPE_SWAPCHAIN_IMAGE_D3D12_KHR"> <type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>ID3D12Resource</type>* <name>texture</name></member> + </type> + <type category="struct" name="XrSwapchainImageMetalKHR" parentstruct="XrSwapchainImageBaseHeader" returnedonly="true"> + <member values="XR_TYPE_SWAPCHAIN_IMAGE_METAL_KHR"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>void</type>* <name>texture</name></member> + </type> + <type category="struct" name="XrSwapchainImageAcquireInfo"> + <member values="XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrSwapchainImageWaitInfo"> + <member values="XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrDuration</type> <name>timeout</name></member> + </type> + <type category="struct" name="XrSwapchainImageReleaseInfo"> + <member values="XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrReferenceSpaceCreateInfo"> + <member values="XR_TYPE_REFERENCE_SPACE_CREATE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrReferenceSpaceType</type> <name>referenceSpaceType</name></member> + <member><type>XrPosef</type> <name>poseInReferenceSpace</name></member> + </type> + <type category="struct" name="XrActionSpaceCreateInfo"> + <member values="XR_TYPE_ACTION_SPACE_CREATE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAction</type> <name>action</name></member> + <member optional="true"><type>XrPath</type> <name>subactionPath</name></member> + <member><type>XrPosef</type> <name>poseInActionSpace</name></member> + </type> + <type category="struct" name="XrSpaceLocation"> + <member values="XR_TYPE_SPACE_LOCATION"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrSpaceLocationFlags</type> <name>locationFlags</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrSpaceVelocity" structextends="XrSpaceLocation"> + <member values="XR_TYPE_SPACE_VELOCITY"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrSpaceVelocityFlags</type> <name>velocityFlags</name></member> + <member><type>XrVector3f</type> <name>linearVelocity</name></member> + <member><type>XrVector3f</type> <name>angularVelocity</name></member> + </type> + <type category="struct" name="XrFovf"> + <member><type>float</type> <name>angleLeft</name></member> + <member><type>float</type> <name>angleRight</name></member> + <member><type>float</type> <name>angleUp</name></member> + <member><type>float</type> <name>angleDown</name></member> + </type> + <type category="struct" name="XrView"> + <member values="XR_TYPE_VIEW"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrFovf</type> <name>fov</name></member> + </type> + <type category="struct" name="XrViewLocateInfo"> + <member values="XR_TYPE_VIEW_LOCATE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></member> + <member><type>XrTime</type> <name>displayTime</name></member> + <member><type>XrSpace</type> <name>space</name></member> + </type> + <type category="struct" name="XrViewState"> + <member values="XR_TYPE_VIEW_STATE"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrViewStateFlags</type> <name>viewStateFlags</name></member> + </type> + <type category="struct" name="XrViewConfigurationView"> + <member values="XR_TYPE_VIEW_CONFIGURATION_VIEW"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>recommendedImageRectWidth</name></member> + <member><type>uint32_t</type> <name>maxImageRectWidth</name></member> + <member><type>uint32_t</type> <name>recommendedImageRectHeight</name></member> + <member><type>uint32_t</type> <name>maxImageRectHeight</name></member> + <member><type>uint32_t</type> <name>recommendedSwapchainSampleCount</name></member> + <member><type>uint32_t</type> <name>maxSwapchainSampleCount</name></member> + </type> + <type category="struct" name="XrSwapchainSubImage"> + <member><type>XrSwapchain</type> <name>swapchain</name></member> + <member><type>XrRect2Di</type> <name>imageRect</name></member> + <member><type>uint32_t</type> <name>imageArrayIndex</name></member> + </type> + <type category="struct" name="XrCompositionLayerBaseHeader"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrCompositionLayerFlags</type> <name>layerFlags</name></member> + <member><type>XrSpace</type> <name>space</name></member> + </type> + <type category="struct" name="XrCompositionLayerProjectionView"> + <member values="XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrFovf</type> <name>fov</name></member> + <member><type>XrSwapchainSubImage</type> <name>subImage</name></member> + </type> + <type category="struct" name="XrCompositionLayerProjection" parentstruct="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_PROJECTION"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrCompositionLayerFlags</type> <name>layerFlags</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>uint32_t</type> <name>viewCount</name></member> + <member len="viewCount">const <type>XrCompositionLayerProjectionView</type>* <name>views</name></member> + </type> + <type category="struct" name="XrCompositionLayerQuad" parentstruct="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_QUAD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrCompositionLayerFlags</type> <name>layerFlags</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrEyeVisibility</type> <name>eyeVisibility</name></member> + <member><type>XrSwapchainSubImage</type> <name>subImage</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrExtent2Df</type> <name>size</name></member> + </type> + <type category="struct" name="XrCompositionLayerCylinderKHR" parentstruct="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_CYLINDER_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrCompositionLayerFlags</type> <name>layerFlags</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrEyeVisibility</type> <name>eyeVisibility</name></member> + <member><type>XrSwapchainSubImage</type> <name>subImage</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>float</type> <name>radius</name></member> + <member><type>float</type> <name>centralAngle</name></member> + <member><type>float</type> <name>aspectRatio</name></member> + </type> + <type category="struct" name="XrCompositionLayerCubeKHR" parentstruct="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_CUBE_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrCompositionLayerFlags</type> <name>layerFlags</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrEyeVisibility</type> <name>eyeVisibility</name></member> + <member><type>XrSwapchain</type> <name>swapchain</name></member> + <member><type>uint32_t</type> <name>imageArrayIndex</name></member> + <member><type>XrQuaternionf</type> <name>orientation</name></member> + </type> + <type category="struct" name="XrCompositionLayerEquirectKHR" parentstruct="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_EQUIRECT_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrCompositionLayerFlags</type> <name>layerFlags</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrEyeVisibility</type> <name>eyeVisibility</name></member> + <member><type>XrSwapchainSubImage</type> <name>subImage</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>float</type> <name>radius</name></member> + <member><type>XrVector2f</type> <name>scale</name></member> + <member><type>XrVector2f</type> <name>bias</name></member> + </type> + <type category="struct" name="XrCompositionLayerDepthInfoKHR" structextends="XrCompositionLayerProjectionView"> + <member values="XR_TYPE_COMPOSITION_LAYER_DEPTH_INFO_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSwapchainSubImage</type> <name>subImage</name></member> + <member><type>float</type> <name>minDepth</name></member> + <member><type>float</type> <name>maxDepth</name></member> + <member><type>float</type> <name>nearZ</name></member> + <member><type>float</type> <name>farZ</name></member> + </type> + <type category="struct" name="XrFrameBeginInfo"> + <member values="XR_TYPE_FRAME_BEGIN_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <!-- This is currently empty, awaiting future extensions. --> + </type> + <type category="struct" name="XrFrameEndInfo"> + <member values="XR_TYPE_FRAME_END_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>displayTime</name></member> + <member><type>XrEnvironmentBlendMode</type> <name>environmentBlendMode</name></member> + <member optional="true"><type>uint32_t</type> <name>layerCount</name></member> + <member optional="true" len="layerCount">const <type>XrCompositionLayerBaseHeader</type>* const* <name>layers</name></member> + </type> + <type category="struct" name="XrFrameWaitInfo"> + <member values="XR_TYPE_FRAME_WAIT_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrFrameState"> + <member values="XR_TYPE_FRAME_STATE"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>predictedDisplayTime</name></member> + <member><type>XrDuration</type> <name>predictedDisplayPeriod</name></member> + <member><type>XrBool32</type> <name>shouldRender</name></member> + </type> + <type category="struct" name="XrHapticBaseHeader"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrHapticVibration" parentstruct="XrHapticBaseHeader"> + <member values="XR_TYPE_HAPTIC_VIBRATION"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrDuration</type> <name>duration</name></member> + <member optional="true"><type>float</type> <name>frequency</name></member> + <member><type>float</type> <name>amplitude</name></member> + </type> + <type category="struct" name="XrEventDataBaseHeader" returnedonly="true"> <!-- top-level, parentstruct="XrBaseOutStructure" causes validation failures --> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrEventDataBuffer"> <!-- top-level, parentstruct="XrBaseInStructure" causes validation failures --> + <member values="XR_TYPE_EVENT_DATA_BUFFER"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint8_t</type> <name>varying</name>[4000]</member> + </type> + <type category="struct" name="XrEventDataEventsLost" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_EVENTS_LOST"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>lostEventCount</name></member> + </type> + <type category="struct" name="XrEventDataInstanceLossPending" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>lossTime</name></member> + </type> + <type category="struct" name="XrEventDataSessionStateChanged" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED"> <type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSession</type> <name>session</name></member> + <member><type>XrSessionState</type> <name>state</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrEventDataReferenceSpaceChangePending" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSession</type> <name>session</name></member> + <member><type>XrReferenceSpaceType</type> <name>referenceSpaceType</name></member> + <member><type>XrTime</type> <name>changeTime</name></member> + <member><type>XrBool32</type> <name>poseValid</name></member> + <member><type>XrPosef</type> <name>poseInPreviousSpace</name></member> + </type> + <type category="struct" name="XrEventDataPerfSettingsEXT" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_PERF_SETTINGS_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPerfSettingsDomainEXT</type> <name>domain</name></member> + <member><type>XrPerfSettingsSubDomainEXT</type> <name>subDomain</name></member> + <member><type>XrPerfSettingsNotificationLevelEXT</type> <name>fromLevel</name></member> + <member><type>XrPerfSettingsNotificationLevelEXT</type> <name>toLevel</name></member> + </type> + <type category="struct" name="XrEventDataVisibilityMaskChangedKHR" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSession</type> <name>session</name></member> + <member><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></member> + <member><type>uint32_t</type> <name>viewIndex</name></member> + </type> + <type category="struct" name="XrViewConfigurationProperties"> + <member values="XR_TYPE_VIEW_CONFIGURATION_PROPERTIES"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></member> + <member><type>XrBool32</type> <name>fovMutable</name></member> + </type> + <type category="struct" name="XrActionStateBoolean"> + <member values="XR_TYPE_ACTION_STATE_BOOLEAN"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>currentState</name></member> + <member><type>XrBool32</type> <name>changedSinceLastSync</name></member> + <member><type>XrTime</type> <name>lastChangeTime</name></member> + <member><type>XrBool32</type> <name>isActive</name></member> + </type> + <type category="struct" name="XrActionStateFloat"> + <member values="XR_TYPE_ACTION_STATE_FLOAT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>float</type> <name>currentState</name></member> + <member><type>XrBool32</type> <name>changedSinceLastSync</name></member> + <member><type>XrTime</type> <name>lastChangeTime</name></member> + <member><type>XrBool32</type> <name>isActive</name></member> + </type> + + <type category="struct" name="XrActionStateVector2f"> + <member values="XR_TYPE_ACTION_STATE_VECTOR2F"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrVector2f</type> <name>currentState</name></member> + <member><type>XrBool32</type> <name>changedSinceLastSync</name></member> + <member><type>XrTime</type> <name>lastChangeTime</name></member> + <member><type>XrBool32</type> <name>isActive</name></member> + </type> + + <type category="struct" name="XrActionStatePose"> + <member values="XR_TYPE_ACTION_STATE_POSE"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>isActive</name></member> + </type> + + <type category="struct" name="XrActionStateGetInfo"> + <member values="XR_TYPE_ACTION_STATE_GET_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAction</type> <name>action</name></member> + <member optional="true"><type>XrPath</type> <name>subactionPath</name></member> + </type> + + <type category="struct" name="XrHapticActionInfo"> + <member values="XR_TYPE_HAPTIC_ACTION_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAction</type> <name>action</name></member> + <member optional="true"><type>XrPath</type> <name>subactionPath</name></member> + </type> + + <type category="struct" name="XrActionSetCreateInfo"> + <member values="XR_TYPE_ACTION_SET_CREATE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>char</type> <name>actionSetName</name>[<enum>XR_MAX_ACTION_SET_NAME_SIZE</enum>]</member> + <member><type>char</type> <name>localizedActionSetName</name>[<enum>XR_MAX_LOCALIZED_ACTION_SET_NAME_SIZE</enum>]</member> + <member><type>uint32_t</type> <name>priority</name></member> + </type> + + <type category="struct" name="XrActionSuggestedBinding"> + <member><type>XrAction</type> <name>action</name></member> + <member><type>XrPath</type> <name>binding</name></member> + </type> + + <type category="struct" name="XrInteractionProfileSuggestedBinding"> + <member values="XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPath</type> <name>interactionProfile</name></member> + <member><type>uint32_t</type> <name>countSuggestedBindings</name></member> + <member len="countSuggestedBindings">const <type>XrActionSuggestedBinding</type>* <name>suggestedBindings</name></member> + </type> + + <type category="struct" name="XrActiveActionSet"> + <member><type>XrActionSet</type> <name>actionSet</name></member> + <member><type>XrPath</type> <name>subactionPath</name></member> + </type> + + <type category="struct" name="XrSessionActionSetsAttachInfo"> + <member values="XR_TYPE_SESSION_ACTION_SETS_ATTACH_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>countActionSets</name></member> + <member len="countActionSets">const <type>XrActionSet</type>* <name>actionSets</name></member> + </type> + + <type category="struct" name="XrActionsSyncInfo"> + <member values="XR_TYPE_ACTIONS_SYNC_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>countActiveActionSets</name></member> + <member optional="true" len="countActiveActionSets">const <type>XrActiveActionSet</type>* <name>activeActionSets</name></member> + </type> + + <type category="struct" name="XrBoundSourcesForActionEnumerateInfo"> + <member values="XR_TYPE_BOUND_SOURCES_FOR_ACTION_ENUMERATE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAction</type> <name>action</name></member> + </type> + + <type category="struct" name="XrInputSourceLocalizedNameGetInfo"> + <member values="XR_TYPE_INPUT_SOURCE_LOCALIZED_NAME_GET_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPath</type> <name>sourcePath</name></member> + <member><type>XrInputSourceLocalizedNameFlags</type> <name>whichComponents</name></member> + </type> + + <type category="struct" name="XrEventDataInteractionProfileChanged" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSession</type> <name>session</name></member> + </type> + + <type category="struct" name="XrInteractionProfileState"> + <member values="XR_TYPE_INTERACTION_PROFILE_STATE"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrPath</type> <name>interactionProfile</name></member> + </type> + + <type category="struct" name="XrActionCreateInfo"> + <member values="XR_TYPE_ACTION_CREATE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>char</type> <name>actionName</name>[<enum>XR_MAX_ACTION_NAME_SIZE</enum>]</member> + <member><type>XrActionType</type> <name>actionType</name></member> + <member optional="true"><type>uint32_t</type> <name>countSubactionPaths</name></member> + <member len="countSubactionPaths" optional="true">const <type>XrPath</type>* <name>subactionPaths</name></member> + <member><type>char</type> <name>localizedActionName</name>[<enum>XR_MAX_LOCALIZED_ACTION_NAME_SIZE</enum>]</member> + </type> + <type category="struct" name="XrInstanceCreateInfoAndroidKHR" structextends="XrInstanceCreateInfo"> + <member values="XR_TYPE_INSTANCE_CREATE_INFO_ANDROID_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>void</type>* <name>applicationVM</name></member> + <member><type>void</type>* <name>applicationActivity</name></member> + </type> + <type category="struct" name="XrVulkanSwapchainFormatListCreateInfoKHR" structextends="XrSwapchainCreateInfo"> + <member values="XR_TYPE_VULKAN_SWAPCHAIN_FORMAT_LIST_CREATE_INFO_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>viewFormatCount</name></member> + <member len="viewFormatCount">const <type>VkFormat</type>* <name>viewFormats</name></member> + </type> + <type category="struct" name="XrDebugUtilsObjectNameInfoEXT"> + <member values="XR_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrObjectType</type> <name>objectType</name></member> + <member><type>uint64_t</type> <name>objectHandle</name></member> + <member optional="true" len="null-terminated">const <type>char</type>* <name>objectName</name></member> + </type> + <type category="struct" name="XrDebugUtilsLabelEXT"> + <member values="XR_TYPE_DEBUG_UTILS_LABEL_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member len="null-terminated">const <type>char</type>* <name>labelName</name></member> + </type> + <type category="struct" name="XrDebugUtilsMessengerCallbackDataEXT"> + <member values="XR_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true" len="null-terminated">const <type>char</type>* <name>messageId</name></member> + <member optional="true" len="null-terminated">const <type>char</type>* <name>functionName</name></member> + <member len="null-terminated">const <type>char</type>* <name>message</name></member> + <member optional="true"><type>uint32_t</type> <name>objectCount</name></member> + <member noautovalidity="true" optional="true" len="objectCount"><type>XrDebugUtilsObjectNameInfoEXT</type>* <name>objects</name></member> + <member optional="true"><type>uint32_t</type> <name>sessionLabelCount</name></member> + <member noautovalidity="true" optional="true" len="sessionLabelCount"><type>XrDebugUtilsLabelEXT</type>* <name>sessionLabels</name></member> + </type> + <type category="struct" name="XrDebugUtilsMessengerCreateInfoEXT" structextends="XrInstanceCreateInfo"> + <member values="XR_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrDebugUtilsMessageSeverityFlagsEXT</type> <name>messageSeverities</name></member> + <member><type>XrDebugUtilsMessageTypeFlagsEXT</type> <name>messageTypes</name></member> + <member><type>PFN_xrDebugUtilsMessengerCallbackEXT</type> <name>userCallback</name></member> + <member optional="true"><type>void</type>* <name>userData</name></member> + </type> + + <!-- struct types for XR_KHR_visibility_mask --> + <type category="struct" name="XrVisibilityMaskKHR"> + <member values="XR_TYPE_VISIBILITY_MASK_KHR"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCountOutput</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector2f</type>* <name>vertices</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCountOutput</name></member> + <member optional="true" len="indexCapacityInput"><type>uint32_t</type>* <name>indices</name></member> + </type> + + <type category="struct" name="XrGraphicsRequirementsOpenGLKHR"> + <member values="XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_KHR"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrVersion</type> <name>minApiVersionSupported</name></member> + <member><type>XrVersion</type> <name>maxApiVersionSupported</name></member> + </type> + <type category="struct" name="XrGraphicsRequirementsOpenGLESKHR"> + <member values="XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_ES_KHR"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrVersion</type> <name>minApiVersionSupported</name></member> + <member><type>XrVersion</type> <name>maxApiVersionSupported</name></member> + </type> + <type category="struct" name="XrGraphicsRequirementsVulkanKHR"> + <member values="XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrVersion</type> <name>minApiVersionSupported</name></member> + <member><type>XrVersion</type> <name>maxApiVersionSupported</name></member> + </type> + <type category="struct" name="XrGraphicsRequirementsD3D11KHR"> + <member values="XR_TYPE_GRAPHICS_REQUIREMENTS_D3D11_KHR"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>LUID</type> <name>adapterLuid</name></member> + <member><type>D3D_FEATURE_LEVEL</type> <name>minFeatureLevel</name></member> + </type> + <type category="struct" name="XrGraphicsRequirementsD3D12KHR"> + <member values="XR_TYPE_GRAPHICS_REQUIREMENTS_D3D12_KHR"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>LUID</type> <name>adapterLuid</name></member> + <member><type>D3D_FEATURE_LEVEL</type> <name>minFeatureLevel</name></member> + </type> + <type category="struct" name="XrGraphicsRequirementsMetalKHR"> + <member values="XR_TYPE_GRAPHICS_REQUIREMENTS_METAL_KHR"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>void</type>* <name>metalDevice</name></member> + </type> + + <!-- XR_KHR_vulkan_enable2 structs --> + <type category="struct" name="XrVulkanInstanceCreateInfoKHR"> + <member values="XR_TYPE_VULKAN_INSTANCE_CREATE_INFO_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSystemId</type> <name>systemId</name></member> + <member optional="true"><type>XrVulkanInstanceCreateFlagsKHR</type> <name>createFlags</name></member> + <member><type>PFN_vkGetInstanceProcAddr</type> <name>pfnGetInstanceProcAddr</name></member> + <member>const <type>VkInstanceCreateInfo</type>* <name>vulkanCreateInfo</name></member> + <member optional="true">const <type>VkAllocationCallbacks</type>* <name>vulkanAllocator</name></member> + </type> + <type category="struct" name="XrVulkanDeviceCreateInfoKHR"> + <member values="XR_TYPE_VULKAN_DEVICE_CREATE_INFO_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSystemId</type> <name>systemId</name></member> + <member optional="true"><type>XrVulkanDeviceCreateFlagsKHR</type> <name>createFlags</name></member> + <member><type>PFN_vkGetInstanceProcAddr</type> <name>pfnGetInstanceProcAddr</name></member> + <member><type>VkPhysicalDevice</type> <name>vulkanPhysicalDevice</name></member> + <member>const <type>VkDeviceCreateInfo</type>* <name>vulkanCreateInfo</name></member> + <member optional="true">const <type>VkAllocationCallbacks</type>* <name>vulkanAllocator</name></member> + </type> + <type category="struct" name="XrGraphicsBindingVulkan2KHR" alias="XrGraphicsBindingVulkanKHR"/> + <type category="struct" name="XrVulkanGraphicsDeviceGetInfoKHR"> + <member values="XR_TYPE_VULKAN_GRAPHICS_DEVICE_GET_INFO_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSystemId</type> <name>systemId</name></member> + <member><type>VkInstance</type> <name>vulkanInstance</name></member> + </type> + <type category="struct" name="XrSwapchainImageVulkan2KHR" alias="XrSwapchainImageVulkanKHR"/> + <type category="struct" name="XrGraphicsRequirementsVulkan2KHR" alias="XrGraphicsRequirementsVulkanKHR"/> + + <!-- XR_META_vulkan_swapchain_create_info structs --> + <type category="struct" name="XrVulkanSwapchainCreateInfoMETA" structextends="XrSwapchainCreateInfo"> + <member values="XR_TYPE_VULKAN_SWAPCHAIN_CREATE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>VkImageCreateFlags</type> <name>additionalCreateFlags</name></member> + <member><type>VkImageUsageFlags</type> <name>additionalUsageFlags</name></member> + </type> + + <!-- XR_EXTX_overlay structs --> + <type category="struct" name="XrSessionCreateInfoOverlayEXTX" structextends="XrSessionCreateInfo"> + <member values="XR_TYPE_SESSION_CREATE_INFO_OVERLAY_EXTX"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrOverlaySessionCreateFlagsEXTX</type> <name>createFlags</name></member> + <member><type>uint32_t</type> <name>sessionLayersPlacement</name></member> + </type> + <type category="struct" name="XrEventDataMainSessionVisibilityChangedEXTX" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_MAIN_SESSION_VISIBILITY_CHANGED_EXTX"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>visible</name></member> + <member><type>XrOverlayMainSessionFlagsEXTX</type> <name>flags</name></member> + </type> + + <!-- XR_FB_display_refresh_rate structs --> + <type category="struct" name="XrEventDataDisplayRefreshRateChangedFB" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>fromDisplayRefreshRate</name></member> + <member><type>float</type> <name>toDisplayRefreshRate</name></member> + </type> + + <!-- struct types for XR_EXT_view_configuration_depth_range --> + <type category="struct" name="XrViewConfigurationDepthRangeEXT" structextends="XrViewConfigurationView"> + <member values="XR_TYPE_VIEW_CONFIGURATION_DEPTH_RANGE_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>float</type> <name>recommendedNearZ</name></member> + <member><type>float</type> <name>minNearZ</name></member> + <member><type>float</type> <name>recommendedFarZ</name></member> + <member><type>float</type> <name>maxFarZ</name></member> + </type> + + <!-- struct types for XR_EPIC_view_configuration_fov --> + <type category="struct" name="XrViewConfigurationViewFovEPIC" structextends="XrViewConfigurationView"> + <member values="XR_TYPE_VIEW_CONFIGURATION_VIEW_FOV_EPIC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrFovf</type> <name>recommendedFov</name></member> + <member><type>XrFovf</type> <name>maxMutableFov</name></member> + </type> + + <!-- struct types for XR_EXT_dpad_binding --> + <type category="struct" name="XrInteractionProfileDpadBindingEXT" parentstruct="XrBindingModificationBaseHeaderKHR"> + <member values="XR_TYPE_INTERACTION_PROFILE_DPAD_BINDING_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPath</type> <name>binding</name></member> + <member><type>XrActionSet</type> <name>actionSet</name></member> + <member><type>float</type> <name>forceThreshold</name></member> + <member><type>float</type> <name>forceThresholdReleased</name></member> + <member><type>float</type> <name>centerRegion</name></member> + <member><type>float</type> <name>wedgeAngle</name></member> + <member><type>XrBool32</type> <name>isSticky</name></member> + <member optional="true">const <type>XrHapticBaseHeader</type>* <name>onHaptic</name></member> + <member optional="true">const <type>XrHapticBaseHeader</type>* <name>offHaptic</name></member> + </type> + + <!-- struct types for XR_VALVE_analog_threshold --> + <type category="struct" name="XrInteractionProfileAnalogThresholdVALVE" parentstruct="XrBindingModificationBaseHeaderKHR"> + <member values="XR_TYPE_INTERACTION_PROFILE_ANALOG_THRESHOLD_VALVE"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAction</type> <name>action</name></member> + <member><type>XrPath</type> <name>binding</name></member> + <member><type>float</type> <name>onThreshold</name></member> + <member><type>float</type> <name>offThreshold</name></member> + <member optional="true">const <type>XrHapticBaseHeader</type>* <name>onHaptic</name></member> + <member optional="true">const <type>XrHapticBaseHeader</type>* <name>offHaptic</name></member> + </type> + + <!-- struct types for XR_KHR_binding_modification --> + <type category="struct" name="XrBindingModificationsKHR" structextends="XrInteractionProfileSuggestedBinding"> + <member values="XR_TYPE_BINDING_MODIFICATIONS_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>bindingModificationCount</name></member> + <member optional="true" len="bindingModificationCount">const <type>XrBindingModificationBaseHeaderKHR</type>* const* <name>bindingModifications</name></member> + </type> + + <type category="struct" name="XrBindingModificationBaseHeaderKHR"> + <member noautovalidity="true"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <!-- The PFN_xrVoidFunction type is used by xrGetInstanceProcAddr below --> + <type category="funcpointer">typedef void (XRAPI_PTR *<name>PFN_xrVoidFunction</name>)(void);</type> + + <!-- The PFN_xrGetInstanceProcAddr type is used by XrNegotiateRuntimeRequest below --> + <type category="funcpointer">typedef XrResult (XRAPI_PTR *<name>PFN_xrGetInstanceProcAddr</name>)(XrInstance instance, const char* name, PFN_xrVoidFunction* function);</type> + + <!-- openxr_loader_negotiation.h --> + <!-- Function pointer prototype for the xrCreateApiLayerInstance function used in place of xrCreateInstance. --> + <!-- This function allows us to pass special API layer information to each layer during the process of creating an Instance. --> + <!-- The typedef is embedded to work around circular dependency between XrApiLayerCreateInfo, next and PFN_xrCreateApiLayerInstance --> + <type category="funcpointer"> +typedef struct XrApiLayerCreateInfo XrApiLayerCreateInfo; +typedef XrResult (XRAPI_PTR *<name>PFN_xrCreateApiLayerInstance</name>)( + const XrInstanceCreateInfo* info, + const XrApiLayerCreateInfo* apiLayerInfo, + XrInstance* instance);</type> + + <!-- The PFN_xrDebugUtilsMessengerCallbackEXT type are used by the XR_EXT_debug_utils extension --> + <type category="funcpointer" requires="XrDebugUtilsMessengerCallbackDataEXT">typedef XrBool32 (XRAPI_PTR *<name>PFN_xrDebugUtilsMessengerCallbackEXT</name>)( + <type>XrDebugUtilsMessageSeverityFlagsEXT</type> messageSeverity, + <type>XrDebugUtilsMessageTypeFlagsEXT</type> messageTypes, + const <type>XrDebugUtilsMessengerCallbackDataEXT</type>* callbackData, + <type>void</type>* userData); + </type> + + <!-- types for XR_EXT_eye_gaze_interaction --> + <type category="struct" name="XrSystemEyeGazeInteractionPropertiesEXT" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_EYE_GAZE_INTERACTION_PROPERTIES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsEyeGazeInteraction</name></member> + </type> + + <type category="struct" name="XrEyeGazeSampleTimeEXT" structextends="XrSpaceLocation"> + <member values="XR_TYPE_EYE_GAZE_SAMPLE_TIME_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <!-- XR_EXT_frame_synthesis --> + <type category="struct" name="XrFrameSynthesisInfoEXT" structextends="XrCompositionLayerProjectionView"> + <member values="XR_TYPE_FRAME_SYNTHESIS_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrFrameSynthesisInfoFlagsEXT</type> <name>layerFlags</name></member> + <member><type>XrSwapchainSubImage</type> <name>motionVectorSubImage</name></member> + <member><type>XrVector4f</type> <name>motionVectorScale</name></member> + <member><type>XrVector4f</type> <name>motionVectorOffset</name></member> + <member><type>XrPosef</type> <name>appSpaceDeltaPose</name></member> + <member><type>XrSwapchainSubImage</type> <name>depthSubImage</name></member> + <member><type>float</type> <name>minDepth</name></member> + <member><type>float</type> <name>maxDepth</name></member> + <member><type>float</type> <name>nearZ</name></member> + <member><type>float</type> <name>farZ</name></member> + </type> + + <type category="struct" name="XrFrameSynthesisConfigViewEXT" structextends="XrViewConfigurationView"> + <member values="XR_TYPE_FRAME_SYNTHESIS_CONFIG_VIEW_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>recommendedMotionVectorImageRectWidth</name></member> + <member><type>uint32_t</type> <name>recommendedMotionVectorImageRectHeight</name></member> + </type> + + <!-- types for XR_MSFT_spatial_anchor --> + <type category="struct" name="XrSpatialAnchorCreateInfoMSFT"> + <member values="XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrSpatialAnchorSpaceCreateInfoMSFT"> + <member values="XR_TYPE_SPATIAL_ANCHOR_SPACE_CREATE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialAnchorMSFT</type> <name>anchor</name></member> + <member><type>XrPosef</type> <name>poseInAnchorSpace</name></member> + </type> + + <!-- types for XR_FB_composition_layer_image_layout --> + <type category="struct" name="XrCompositionLayerImageLayoutFB" structextends="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_IMAGE_LAYOUT_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrCompositionLayerImageLayoutFlagsFB</type> <name>flags</name></member> + </type> + + <!-- types for XR_FB_composition_layer_alpha_blend --> + <type category="struct" name="XrCompositionLayerAlphaBlendFB" structextends="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_ALPHA_BLEND_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBlendFactorFB</type> <name>srcFactorColor</name></member> + <member><type>XrBlendFactorFB</type> <name>dstFactorColor</name></member> + <member><type>XrBlendFactorFB</type> <name>srcFactorAlpha</name></member> + <member><type>XrBlendFactorFB</type> <name>dstFactorAlpha</name></member> + </type> + + + <!-- types for XR_MNDX_egl_enable --> + <type category="funcpointer">typedef PFN_xrVoidFunction (*<name>PFN_xrEglGetProcAddressMNDX</name>)(const <type>char</type> *name);</type> + + <type category="struct" name="XrGraphicsBindingEGLMNDX" structextends="XrSessionCreateInfo"> + <member values="XR_TYPE_GRAPHICS_BINDING_EGL_MNDX"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>PFN_xrEglGetProcAddressMNDX</type> <name>getProcAddress</name></member> + <member><type>EGLDisplay</type> <name>display</name></member> + <member><type>EGLConfig</type> <name>config</name></member> + <member><type>EGLContext</type> <name>context</name></member> + </type> + + <!-- types for XR_MSFT_spatial_graph_bridge --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSpatialGraphNodeBindingMSFT</name>)</type> + <type category="struct" name="XrSpatialGraphNodeSpaceCreateInfoMSFT"> + <member values="XR_TYPE_SPATIAL_GRAPH_NODE_SPACE_CREATE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialGraphNodeTypeMSFT</type> <name>nodeType</name></member> + <member><type>uint8_t</type> <name>nodeId</name>[<enum>XR_GUID_SIZE_MSFT</enum>]</member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrSpatialGraphStaticNodeBindingCreateInfoMSFT"> + <member values="XR_TYPE_SPATIAL_GRAPH_STATIC_NODE_BINDING_CREATE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrPosef</type> <name>poseInSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrSpatialGraphNodeBindingPropertiesGetInfoMSFT"> + <member values="XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_GET_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrSpatialGraphNodeBindingPropertiesMSFT"> + <member values="XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint8_t</type> <name>nodeId</name>[<enum>XR_GUID_SIZE_MSFT</enum>]</member> + <member><type>XrPosef</type> <name>poseInNodeSpace</name></member> + </type> + + <!-- XR_EXT_hand_tracking --> + <type name="XrHandEXT" category="enum"/> + <type name="XrHandJointEXT" category="enum"/> + <type name="XrHandJointSetEXT" category="enum"/> + + <type category="struct" name="XrSystemHandTrackingPropertiesEXT" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_HAND_TRACKING_PROPERTIES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsHandTracking</name></member> + </type> + <type category="struct" name="XrHandTrackerCreateInfoEXT"> + <member values="XR_TYPE_HAND_TRACKER_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrHandEXT</type> <name>hand</name></member> + <member><type>XrHandJointSetEXT</type> <name>handJointSet</name></member> + </type> + <type category="struct" name="XrHandJointsLocateInfoEXT"> + <member values="XR_TYPE_HAND_JOINTS_LOCATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrHandJointLocationEXT"> + <member optional="true"><type>XrSpaceLocationFlags</type> <name>locationFlags</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>float</type> <name>radius</name></member> + </type> + <type category="struct" name="XrHandJointVelocityEXT" returnedonly="true"> + <member optional="true"><type>XrSpaceVelocityFlags</type> <name>velocityFlags</name></member> + <member><type>XrVector3f</type> <name>linearVelocity</name></member> + <member><type>XrVector3f</type> <name>angularVelocity</name></member> + </type> + <type category="struct" name="XrHandJointLocationsEXT"> + <member values="XR_TYPE_HAND_JOINT_LOCATIONS_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>isActive</name></member> + <member><type>uint32_t</type> <name>jointCount</name></member> + <member len="jointCount"><type>XrHandJointLocationEXT</type>* <name>jointLocations</name></member> + </type> + <type category="struct" name="XrHandJointVelocitiesEXT" structextends="XrHandJointLocationsEXT"> + <member values="XR_TYPE_HAND_JOINT_VELOCITIES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>jointCount</name></member> + <member len="jointCount"><type>XrHandJointVelocityEXT</type>* <name>jointVelocities</name></member> + </type> + + <!-- XR_FB_face_tracking structs --> + <type category="struct" name="XrSystemFaceTrackingPropertiesFB" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsFaceTracking</name></member> + </type> + <type category="struct" name="XrFaceTrackerCreateInfoFB"> + <member values="XR_TYPE_FACE_TRACKER_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrFaceExpressionSetFB</type> <name>faceExpressionSet</name></member> + </type> + <type category="struct" name="XrFaceExpressionInfoFB"> + <member values="XR_TYPE_FACE_EXPRESSION_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrFaceExpressionStatusFB"> + <member><type>XrBool32</type> <name>isValid</name></member> + <member><type>XrBool32</type> <name>isEyeFollowingBlendshapesValid</name></member> + </type> + <type category="struct" name="XrFaceExpressionWeightsFB"> + <member values="XR_TYPE_FACE_EXPRESSION_WEIGHTS_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>weightCount</name></member> + <member len="weightCount"><type>float</type>* <name>weights</name></member> + <member><type>uint32_t</type> <name>confidenceCount</name></member> + <member len="confidenceCount"><type>float</type>* <name>confidences</name></member> + <member><type>XrFaceExpressionStatusFB</type> <name>status</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <!-- XR_FB_face_tracking2 structs --> + <type category="struct" name="XrSystemFaceTrackingProperties2FB" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES2_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsVisualFaceTracking</name></member> + <member><type>XrBool32</type> <name>supportsAudioFaceTracking</name></member> + </type> + <type category="struct" name="XrFaceTrackerCreateInfo2FB"> + <member values="XR_TYPE_FACE_TRACKER_CREATE_INFO2_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrFaceExpressionSet2FB</type> <name>faceExpressionSet</name></member> + <member optional="true"><type>uint32_t</type> <name>requestedDataSourceCount</name></member> + <member optional="true" len="requestedDataSourceCount"><type>XrFaceTrackingDataSource2FB</type>* <name>requestedDataSources</name></member> + </type> + <type category="struct" name="XrFaceExpressionInfo2FB"> + <member values="XR_TYPE_FACE_EXPRESSION_INFO2_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrFaceExpressionWeights2FB"> + <member values="XR_TYPE_FACE_EXPRESSION_WEIGHTS2_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>weightCount</name></member> + <member len="weightCount"><type>float</type>* <name>weights</name></member> + <member><type>uint32_t</type> <name>confidenceCount</name></member> + <member len="confidenceCount"><type>float</type>* <name>confidences</name></member> + <member><type>XrBool32</type> <name>isValid</name></member> + <member><type>XrBool32</type> <name>isEyeFollowingBlendshapesValid</name></member> + <member><type>XrFaceTrackingDataSource2FB</type> <name>dataSource</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <!-- XR_META_face_tracking_visemes--> + <type category="struct" name="XrSystemFaceTrackingVisemesPropertiesMETA" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_FACE_TRACKING_VISEMES_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsVisemes</name></member> + </type> + <type category="struct" name="XrFaceTrackingVisemesMETA" structextends="XrFaceExpressionWeights2FB"> + <member values="XR_TYPE_FACE_TRACKING_VISEMES_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>isValid</name></member> + <member><type>float</type> <name>visemes</name>[<enum>XR_FACE_TRACKING_VISEME_COUNT_META</enum>]</member> + </type> + + <!-- XR_FB_body_tracking structs --> + <type category="struct" name="XrSystemBodyTrackingPropertiesFB" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsBodyTracking</name></member> + </type> + <type category="struct" name="XrBodyTrackerCreateInfoFB"> + <member values="XR_TYPE_BODY_TRACKER_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBodyJointSetFB</type> <name>bodyJointSet</name></member> + </type> + <type category="struct" name="XrBodySkeletonJointFB"> + <member><type>int32_t</type> <name>joint</name></member> + <member><type>int32_t</type> <name>parentJoint</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrBodySkeletonFB"> + <member values="XR_TYPE_BODY_SKELETON_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>jointCount</name></member> + <member len="jointCount"><type>XrBodySkeletonJointFB</type>* <name>joints</name></member> + </type> + <type category="struct" name="XrBodyJointsLocateInfoFB"> + <member values="XR_TYPE_BODY_JOINTS_LOCATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrBodyJointLocationFB"> + <member><type>XrSpaceLocationFlags</type> <name>locationFlags</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrBodyJointLocationsFB" returnedonly="true"> + <member values="XR_TYPE_BODY_JOINT_LOCATIONS_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>isActive</name></member> + <member><type>float</type> <name>confidence</name></member> + <member><type>uint32_t</type> <name>jointCount</name></member> + <member len="jointCount"><type>XrBodyJointLocationFB</type>* <name>jointLocations</name></member> + <member><type>uint32_t</type> <name>skeletonChangedCount</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <!-- XR_META_body_tracking_full_body structs --> + <type category="struct" name="XrSystemPropertiesBodyTrackingFullBodyMETA" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_FULL_BODY_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsFullBodyTracking</name></member> + </type> + + <!-- XR_META_body_tracking_calibration structs --> + <type name="XrBodyTrackingCalibrationInfoMETA" category="struct"> + <member values="XR_TYPE_BODY_TRACKING_CALIBRATION_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>bodyHeight</name></member> + </type> + + <type name="XrBodyTrackingCalibrationStatusMETA" category="struct" structextends="XrBodyJointLocationsFB" returnedonly="true"> + <member values="XR_TYPE_BODY_TRACKING_CALIBRATION_STATUS_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBodyTrackingCalibrationStateMETA</type> <name>status</name></member> + </type> + + <type name="XrSystemPropertiesBodyTrackingCalibrationMETA" category="struct" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_CALIBRATION_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsHeightOverride</name></member> + </type> + + <!-- XR_META_body_tracking_fidelity structs --> + <type name="XrBodyTrackingFidelityStatusMETA" category="struct" structextends="XrBodyJointLocationsFB" returnedonly="true"> + <member values="XR_TYPE_BODY_TRACKING_FIDELITY_STATUS_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBodyTrackingFidelityMETA</type> <name>fidelity</name></member> + </type> + + <type name="XrSystemPropertiesBodyTrackingFidelityMETA" category="struct" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_FIDELITY_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsBodyTrackingFidelity</name></member> + </type> + + <!-- XR_FB_eye_tracking_social structs --> + <type category="struct" name="XrSystemEyeTrackingPropertiesFB" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_EYE_TRACKING_PROPERTIES_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsEyeTracking</name></member> + </type> + <type category="struct" name="XrEyeTrackerCreateInfoFB"> + <member values="XR_TYPE_EYE_TRACKER_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrEyeGazesInfoFB"> + <member values="XR_TYPE_EYE_GAZES_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrEyeGazeFB"> + <member><type>XrBool32</type> <name>isValid</name></member> + <member><type>XrPosef</type> <name>gazePose</name></member> + <member><type>float</type> <name>gazeConfidence</name></member> + </type> + <type category="struct" name="XrEyeGazesFB"> + <member values="XR_TYPE_EYE_GAZES_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrEyeGazeFB</type> <name>gaze</name>[XR_EYE_POSITION_COUNT_FB]</member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <!-- XR_EXT_hand_joints_motion_range --> + <type name="XrHandJointsMotionRangeEXT" category="enum"/> + <type category="struct" name="XrHandJointsMotionRangeInfoEXT" structextends="XrHandJointsLocateInfoEXT"> + <member values="XR_TYPE_HAND_JOINTS_MOTION_RANGE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrHandJointsMotionRangeEXT</type> <name>handJointsMotionRange</name></member> + </type> + + <!-- XR_EXT_hand_tracking_data_source --> + <type name="XrHandTrackingDataSourceEXT" category="enum"/> + <type category="struct" name="XrHandTrackingDataSourceInfoEXT" structextends="XrHandTrackerCreateInfoEXT"> + <member values="XR_TYPE_HAND_TRACKING_DATA_SOURCE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>requestedDataSourceCount</name></member> + <member len="requestedDataSourceCount"><type>XrHandTrackingDataSourceEXT</type>* <name>requestedDataSources</name></member> + </type> + + <type category="struct" name="XrHandTrackingDataSourceStateEXT" structextends="XrHandJointLocationsEXT" returnedonly="true"> + <member values="XR_TYPE_HAND_TRACKING_DATA_SOURCE_STATE_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>isActive</name></member> + <member optional="true"><type>XrHandTrackingDataSourceEXT</type> <name>dataSource</name></member> + </type> + + <!-- XR_MSFT_hand_tracking_mesh --> + <type name="XrHandPoseTypeMSFT" category="enum"/> + <type category="struct" name="XrHandMeshSpaceCreateInfoMSFT"> + <member values="XR_TYPE_HAND_MESH_SPACE_CREATE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrHandPoseTypeMSFT</type> <name>handPoseType</name></member> + <member><type>XrPosef</type> <name>poseInHandMeshSpace</name></member> + </type> + <type category="struct" name="XrHandMeshUpdateInfoMSFT"> + <member values="XR_TYPE_HAND_MESH_UPDATE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrHandPoseTypeMSFT</type> <name>handPoseType</name></member> + </type> + <type category="struct" name="XrHandMeshMSFT"> + <member values="XR_TYPE_HAND_MESH_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>isActive</name></member> + <member><type>XrBool32</type> <name>indexBufferChanged</name></member> + <member><type>XrBool32</type> <name>vertexBufferChanged</name></member> + <member><type>XrHandMeshIndexBufferMSFT</type> <name>indexBuffer</name></member> + <member><type>XrHandMeshVertexBufferMSFT</type> <name>vertexBuffer</name></member> + </type> + <type category="struct" name="XrHandMeshIndexBufferMSFT"> + <member optional="true"><type>uint32_t</type> <name>indexBufferKey</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCountOutput</name></member> + <member optional="true" len="indexCapacityInput"><type>uint32_t</type>* <name>indices</name></member> + </type> + <type category="struct" name="XrHandMeshVertexBufferMSFT"> + <member optional="true"><type>XrTime</type> <name>vertexUpdateTime</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCountOutput</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrHandMeshVertexMSFT</type>* <name>vertices</name></member> + </type> + <type category="struct" name="XrHandMeshVertexMSFT"> + <member><type>XrVector3f</type> <name>position</name></member> + <member><type>XrVector3f</type> <name>normal</name></member> + </type> + <type category="struct" name="XrSystemHandTrackingMeshPropertiesMSFT" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_HAND_TRACKING_MESH_PROPERTIES_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsHandTrackingMesh</name></member> + <member><type>uint32_t</type> <name>maxHandMeshIndexCount</name></member> + <member><type>uint32_t</type> <name>maxHandMeshVertexCount</name></member> + </type> + <type category="struct" name="XrHandPoseTypeInfoMSFT" structextends="XrHandTrackerCreateInfoEXT"> + <member values="XR_TYPE_HAND_POSE_TYPE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrHandPoseTypeMSFT</type> <name>handPoseType</name></member> + </type> + + <!-- XR_MSFT_secondary_view_configuration --> + <type category="struct" name="XrSecondaryViewConfigurationSessionBeginInfoMSFT" structextends="XrSessionBeginInfo"> + <member values="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_SESSION_BEGIN_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>viewConfigurationCount</name></member> + <member len="viewConfigurationCount">const <type>XrViewConfigurationType</type>* <name>enabledViewConfigurationTypes</name></member> + </type> + <type category="struct" name="XrSecondaryViewConfigurationStateMSFT"> + <member values="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_STATE_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></member> + <member><type>XrBool32</type> <name>active</name></member> + </type> + <type category="struct" name="XrSecondaryViewConfigurationFrameStateMSFT" structextends="XrFrameState"> + <member values="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_FRAME_STATE_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>viewConfigurationCount</name></member> + <member len="viewConfigurationCount"><type>XrSecondaryViewConfigurationStateMSFT</type>* <name>viewConfigurationStates</name></member> + </type> + <type category="struct" name="XrSecondaryViewConfigurationFrameEndInfoMSFT" structextends="XrFrameEndInfo"> + <member values="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_FRAME_END_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>viewConfigurationCount</name></member> + <member len="viewConfigurationCount">const <type>XrSecondaryViewConfigurationLayerInfoMSFT</type>* <name>viewConfigurationLayersInfo</name></member> + </type> + <type category="struct" name="XrSecondaryViewConfigurationLayerInfoMSFT"> + <member values="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_LAYER_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></member> + <member><type>XrEnvironmentBlendMode</type> <name>environmentBlendMode</name></member> + <member><type>uint32_t</type> <name>layerCount</name></member> + <member len="layerCount">const <type>XrCompositionLayerBaseHeader</type>* const* <name>layers</name></member> + </type> + <type category="struct" name="XrSecondaryViewConfigurationSwapchainCreateInfoMSFT" structextends="XrSwapchainCreateInfo"> + <member values="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_SWAPCHAIN_CREATE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></member> + </type> + + <!-- XR_MSFT_holographic_window_attachment --> + <type category="struct" name="XrHolographicWindowAttachmentMSFT" structextends="XrSessionCreateInfo" protect="XR_USE_PLATFORM_WIN32"> + <member values="XR_TYPE_HOLOGRAPHIC_WINDOW_ATTACHMENT_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>IUnknown</type>* <name>holographicSpace</name></member> + <member><type>IUnknown</type>* <name>coreWindow</name></member> + </type> + + <!-- XR_FB_android_surface_swapchain_create --> + <type category="struct" name="XrAndroidSurfaceSwapchainCreateInfoFB" structextends="XrSwapchainCreateInfo" protect="XR_USE_PLATFORM_ANDROID"> + <member values="XR_TYPE_ANDROID_SURFACE_SWAPCHAIN_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAndroidSurfaceSwapchainFlagsFB</type> <name>createFlags</name></member> + </type> + + <!-- XR_FB_swapchain_update_state structs --> + <type category="struct" name="XrSwapchainStateBaseHeaderFB"> + <member><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + </type> + + <!-- XR_FB_swapchain_update_state_android_surface structs --> + <type category="struct" name="XrSwapchainStateAndroidSurfaceDimensionsFB" parentstruct="XrSwapchainStateBaseHeaderFB" protect="XR_USE_PLATFORM_ANDROID"> + <member values="XR_TYPE_SWAPCHAIN_STATE_ANDROID_SURFACE_DIMENSIONS_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>width</name></member> + <member><type>uint32_t</type> <name>height</name></member> + </type> + + <!-- XR_FB_swapchain_update_state_opengl_es structs --> + <type category="struct" name="XrSwapchainStateSamplerOpenGLESFB" parentstruct="XrSwapchainStateBaseHeaderFB" protect="XR_USE_GRAPHICS_API_OPENGL_ES"> + <member values="XR_TYPE_SWAPCHAIN_STATE_SAMPLER_OPENGL_ES_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>EGLenum</type> <name>minFilter</name></member> + <member><type>EGLenum</type> <name>magFilter</name></member> + <member><type>EGLenum</type> <name>wrapModeS</name></member> + <member><type>EGLenum</type> <name>wrapModeT</name></member> + <member><type>EGLenum</type> <name>swizzleRed</name></member> + <member><type>EGLenum</type> <name>swizzleGreen</name></member> + <member><type>EGLenum</type> <name>swizzleBlue</name></member> + <member><type>EGLenum</type> <name>swizzleAlpha</name></member> + <member><type>float</type> <name>maxAnisotropy</name></member> + <member><type>XrColor4f</type> <name>borderColor</name></member> + </type> + + <!-- XR_FB_swapchain_update_state_vulkan structs --> + <type category="struct" name="XrSwapchainStateSamplerVulkanFB" parentstruct="XrSwapchainStateBaseHeaderFB" protect="XR_USE_GRAPHICS_API_VULKAN"> + <member values="XR_TYPE_SWAPCHAIN_STATE_SAMPLER_VULKAN_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>VkFilter</type> <name>minFilter</name></member> + <member><type>VkFilter</type> <name>magFilter</name></member> + <member><type>VkSamplerMipmapMode</type> <name>mipmapMode</name></member> + <member><type>VkSamplerAddressMode</type> <name>wrapModeS</name></member> + <member><type>VkSamplerAddressMode</type> <name>wrapModeT</name></member> + <member><type>VkComponentSwizzle</type> <name>swizzleRed</name></member> + <member><type>VkComponentSwizzle</type> <name>swizzleGreen</name></member> + <member><type>VkComponentSwizzle</type> <name>swizzleBlue</name></member> + <member><type>VkComponentSwizzle</type> <name>swizzleAlpha</name></member> + <member><type>float</type> <name>maxAnisotropy</name></member> + <member><type>XrColor4f</type> <name>borderColor</name></member> + </type> + + <!-- XR_FB_composition_layer_secure_content structs --> + <type category="struct" name="XrCompositionLayerSecureContentFB" structextends="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_SECURE_CONTENT_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCompositionLayerSecureContentFlagsFB</type> <name>flags</name></member> + </type> + + <!-- XR_KHR_loader_init --> + <type category="struct" name="XrLoaderInitInfoBaseHeaderKHR"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <!-- XR_KHR_loader_init_android --> + <type category="struct" name="XrLoaderInitInfoAndroidKHR" parentstruct="XrLoaderInitInfoBaseHeaderKHR"> + <member values="XR_TYPE_LOADER_INIT_INFO_ANDROID_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>void</type>* <name>applicationVM</name></member> + <member><type>void</type>* <name>applicationContext</name></member> + </type> + + <!-- XR_KHR_composition_layer_equirect2 --> + <type category="struct" name="XrCompositionLayerEquirect2KHR" parentstruct="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_EQUIRECT2_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrCompositionLayerFlags</type> <name>layerFlags</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrEyeVisibility</type> <name>eyeVisibility</name></member> + <member><type>XrSwapchainSubImage</type> <name>subImage</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>float</type> <name>radius</name></member> + <member><type>float</type> <name>centralHorizontalAngle</name></member> + <member><type>float</type> <name>upperVerticalAngle</name></member> + <member><type>float</type> <name>lowerVerticalAngle</name></member> + </type> + + <!-- XR_KHR_composition_layer_color_scale_bias --> + <type category="struct" name="XrCompositionLayerColorScaleBiasKHR" structextends="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_COLOR_SCALE_BIAS_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrColor4f</type> <name>colorScale</name></member> + <member><type>XrColor4f</type> <name>colorBias</name></member> + </type> + + <!-- XR_MSFT_controller_model --> + <type category="struct" name="XrControllerModelKeyStateMSFT"> + <member values="XR_TYPE_CONTROLLER_MODEL_KEY_STATE_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrControllerModelKeyMSFT</type> <name>modelKey</name></member> + </type> + <type category="struct" name="XrControllerModelNodePropertiesMSFT"> + <member values="XR_TYPE_CONTROLLER_MODEL_NODE_PROPERTIES_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>char</type> <name>parentNodeName</name>[<enum>XR_MAX_CONTROLLER_MODEL_NODE_NAME_SIZE_MSFT</enum>]</member> + <member><type>char</type> <name>nodeName</name>[<enum>XR_MAX_CONTROLLER_MODEL_NODE_NAME_SIZE_MSFT</enum>]</member> + </type> + <type category="struct" name="XrControllerModelPropertiesMSFT"> + <member values="XR_TYPE_CONTROLLER_MODEL_PROPERTIES_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>nodeCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>nodeCountOutput</name></member> + <member optional="true" len="nodeCapacityInput"><type>XrControllerModelNodePropertiesMSFT</type>* <name>nodeProperties</name></member> + </type> + <type category="struct" name="XrControllerModelNodeStateMSFT"> + <member values="XR_TYPE_CONTROLLER_MODEL_NODE_STATE_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrPosef</type> <name>nodePose</name></member> + </type> + <type category="struct" name="XrControllerModelStateMSFT"> + <member values="XR_TYPE_CONTROLLER_MODEL_STATE_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>nodeCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>nodeCountOutput</name></member> + <member optional="true" len="nodeCapacityInput"><type>XrControllerModelNodeStateMSFT</type>* <name>nodeStates</name></member> + </type> + + <!-- XR_MSFT_scene_understanding --> + <type category="handle" parent="XrSession"> + <type>XR_DEFINE_HANDLE</type>(<name>XrSceneObserverMSFT</name>)</type> + <type category="handle" parent="XrSceneObserverMSFT"> + <type>XR_DEFINE_HANDLE</type>(<name>XrSceneMSFT</name>)</type> + <type name="XrSceneObjectTypeMSFT" category="enum"/> + <type name="XrScenePlaneAlignmentTypeMSFT" category="enum"/> + <type name="XrSceneComputeStateMSFT" category="enum"/> + <type name="XrSceneComputeFeatureMSFT" category="enum"/> + <type name="XrSceneComputeConsistencyMSFT" category="enum"/> + <type name="XrSceneComponentTypeMSFT" category="enum"/> + <type name="XrMeshComputeLodMSFT" category="enum"/> + <type category="struct" name="XrUuidMSFT"> + <member><type>uint8_t</type> <name>bytes</name>[16]</member> + </type> + <type category="struct" name="XrSceneObserverCreateInfoMSFT"> + <member values="XR_TYPE_SCENE_OBSERVER_CREATE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrSceneCreateInfoMSFT"> + <member values="XR_TYPE_SCENE_CREATE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrNewSceneComputeInfoMSFT"> + <member values="XR_TYPE_NEW_SCENE_COMPUTE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>requestedFeatureCount</name></member> + <member len="requestedFeatureCount">const <type>XrSceneComputeFeatureMSFT</type>* <name>requestedFeatures</name></member> + <member><type>XrSceneComputeConsistencyMSFT</type> <name>consistency</name></member> + <member><type>XrSceneBoundsMSFT</type> <name>bounds</name></member> + </type> + <type category="struct" name="XrVisualMeshComputeLodInfoMSFT" structextends="XrNewSceneComputeInfoMSFT"> + <member values="XR_TYPE_VISUAL_MESH_COMPUTE_LOD_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrMeshComputeLodMSFT</type> <name>lod</name></member> + </type> + + <type category="struct" name="XrSceneSphereBoundMSFT"> + <member><type>XrVector3f</type> <name>center</name></member> + <member><type>float</type> <name>radius</name></member> + </type> + + <type category="struct" name="XrSceneOrientedBoxBoundMSFT"> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrVector3f</type> <name>extents</name></member> + </type> + + <type category="struct" name="XrSceneFrustumBoundMSFT"> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrFovf</type> <name>fov</name></member> + <member><type>float</type> <name>farDistance</name></member> + </type> + + <type category="struct" name="XrSceneBoundsMSFT"> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member optional="true"><type>uint32_t</type> <name>sphereCount</name></member> + <member optional="true" len="sphereCount">const <type>XrSceneSphereBoundMSFT</type>* <name>spheres</name></member> + <member optional="true"><type>uint32_t</type> <name>boxCount</name></member> + <member optional="true" len="boxCount">const <type>XrSceneOrientedBoxBoundMSFT</type>* <name>boxes</name></member> + <member optional="true"><type>uint32_t</type> <name>frustumCount</name></member> + <member optional="true" len="frustumCount">const <type>XrSceneFrustumBoundMSFT</type>* <name>frustums</name></member> + </type> + <type category="struct" name="XrSceneComponentMSFT"> + <member><type>XrSceneComponentTypeMSFT</type> <name>componentType</name></member> + <member><type>XrUuidMSFT</type> <name>id</name></member> + <member optional="true"><type>XrUuidMSFT</type> <name>parentId</name></member> + <member><type>XrTime</type> <name>updateTime</name></member> + </type> + <type category="struct" name="XrSceneComponentsMSFT"> + <member values="XR_TYPE_SCENE_COMPONENTS_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>componentCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>componentCountOutput</name></member> + <member optional="true" len="componentCapacityInput"><type>XrSceneComponentMSFT</type>* <name>components</name></member> + </type> + <type category="struct" name="XrSceneComponentsGetInfoMSFT"> + <member values="XR_TYPE_SCENE_COMPONENTS_GET_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSceneComponentTypeMSFT</type> <name>componentType</name></member> + </type> + <type category="struct" name="XrSceneComponentLocationMSFT"> + <member optional="true"><type>XrSpaceLocationFlags</type> <name>flags</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrSceneComponentLocationsMSFT"> + <member values="XR_TYPE_SCENE_COMPONENT_LOCATIONS_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>locationCount</name></member> + <member optional="true" len="locationCount"><type>XrSceneComponentLocationMSFT</type>* <name>locations</name></member> + </type> + <type category="struct" name="XrSceneComponentsLocateInfoMSFT"> + <member values="XR_TYPE_SCENE_COMPONENTS_LOCATE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member optional="true"><type>uint32_t</type> <name>componentIdCount</name></member> + <member optional="true" len="componentIdCount">const <type>XrUuidMSFT</type>* <name>componentIds</name></member> + </type> + <type category="struct" name="XrSceneObjectMSFT"> + <member><type>XrSceneObjectTypeMSFT</type> <name>objectType</name></member> + </type> + <type category="struct" name="XrSceneObjectsMSFT" structextends="XrSceneComponentsMSFT"> + <member values="XR_TYPE_SCENE_OBJECTS_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>sceneObjectCount</name></member> + <member optional="true" len="sceneObjectCount"><type>XrSceneObjectMSFT</type>* <name>sceneObjects</name></member> + </type> + <type category="struct" name="XrSceneComponentParentFilterInfoMSFT" structextends="XrSceneComponentsGetInfoMSFT"> + <member values="XR_TYPE_SCENE_COMPONENT_PARENT_FILTER_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrUuidMSFT</type> <name>parentId</name></member> + </type> + <type category="struct" name="XrSceneObjectTypesFilterInfoMSFT" structextends="XrSceneComponentsGetInfoMSFT"> + <member values="XR_TYPE_SCENE_OBJECT_TYPES_FILTER_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>objectTypeCount</name></member> + <member optional="true" len="objectTypeCount">const <type>XrSceneObjectTypeMSFT</type>* <name>objectTypes</name></member> + </type> + <type category="struct" name="XrScenePlaneMSFT"> + <member><type>XrScenePlaneAlignmentTypeMSFT</type> <name>alignment</name></member> + <member><type>XrExtent2Df</type> <name>size</name></member> + <member><type>uint64_t</type> <name>meshBufferId</name></member> + <member><type>XrBool32</type> <name>supportsIndicesUint16</name></member> + </type> + <type category="struct" name="XrScenePlanesMSFT" structextends="XrSceneComponentsMSFT"> + <member values="XR_TYPE_SCENE_PLANES_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>scenePlaneCount</name></member> + <member optional="true" len="scenePlaneCount"><type>XrScenePlaneMSFT</type>* <name>scenePlanes</name></member> + </type> + <type category="struct" name="XrScenePlaneAlignmentFilterInfoMSFT" structextends="XrSceneComponentsGetInfoMSFT"> + <member values="XR_TYPE_SCENE_PLANE_ALIGNMENT_FILTER_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>alignmentCount</name></member> + <member optional="true" len="alignmentCount">const <type>XrScenePlaneAlignmentTypeMSFT</type>* <name>alignments</name></member> + </type> + <type category="struct" name="XrSceneMeshMSFT"> + <member><type>uint64_t</type> <name>meshBufferId</name></member> + <member><type>XrBool32</type> <name>supportsIndicesUint16</name></member> + </type> + <type category="struct" name="XrSceneMeshesMSFT" structextends="XrSceneComponentsMSFT"> + <member values="XR_TYPE_SCENE_MESHES_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>sceneMeshCount</name></member> + <member optional="true" len="sceneMeshCount"><type>XrSceneMeshMSFT</type>* <name>sceneMeshes</name></member> + </type> + <type category="struct" name="XrSceneMeshBuffersGetInfoMSFT"> + <member values="XR_TYPE_SCENE_MESH_BUFFERS_GET_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint64_t</type> <name>meshBufferId</name></member> + </type> + <type category="struct" name="XrSceneMeshBuffersMSFT"> + <member values="XR_TYPE_SCENE_MESH_BUFFERS_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrSceneMeshVertexBufferMSFT" structextends="XrSceneMeshBuffersMSFT"> + <member values="XR_TYPE_SCENE_MESH_VERTEX_BUFFER_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCountOutput</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector3f</type>* <name>vertices</name></member> + </type> + <type category="struct" name="XrSceneMeshIndicesUint32MSFT" structextends="XrSceneMeshBuffersMSFT"> + <member values="XR_TYPE_SCENE_MESH_INDICES_UINT32_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCountOutput</name></member> + <member optional="true" len="indexCapacityInput"><type>uint32_t</type>* <name>indices</name></member> + </type> + <type category="struct" name="XrSceneMeshIndicesUint16MSFT" structextends="XrSceneMeshBuffersMSFT"> + <member values="XR_TYPE_SCENE_MESH_INDICES_UINT16_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCountOutput</name></member> + <member optional="true" len="indexCapacityInput"><type>uint16_t</type>* <name>indices</name></member> + </type> + + <!-- XR_MSFT_scene_understanding_serialization --> + <type category="struct" name="XrSerializedSceneFragmentDataGetInfoMSFT"> + <member values="XR_TYPE_SERIALIZED_SCENE_FRAGMENT_DATA_GET_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrUuidMSFT</type> <name>sceneFragmentId</name></member> + </type> + <type category="struct" name="XrDeserializeSceneFragmentMSFT"> + <member optional="true"><type>uint32_t</type> <name>bufferSize</name></member> + <member optional="true" len="bufferSize">const <type>uint8_t</type>* <name>buffer</name></member> + </type> + <type category="struct" name="XrSceneDeserializeInfoMSFT"> + <member values="XR_TYPE_SCENE_DESERIALIZE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>fragmentCount</name></member> + <member optional="true" len="fragmentCount">const <type>XrDeserializeSceneFragmentMSFT</type>* <name>fragments</name></member> + </type> + + <!-- XR_MSFT_scene_marker --> + <type name="XrSceneMarkerTypeMSFT" category="enum"/> + <type name="XrSceneMarkerQRCodeSymbolTypeMSFT" category="enum"/> + <type category="struct" name="XrSceneMarkerMSFT" returnedonly="true"> + <member><type>XrSceneMarkerTypeMSFT</type> <name>markerType</name></member> + <member><type>XrTime</type> <name>lastSeenTime</name></member> + <member><type>XrOffset2Df</type> <name>center</name></member> + <member><type>XrExtent2Df</type> <name>size</name></member> + </type> + <type category="struct" name="XrSceneMarkersMSFT" structextends="XrSceneComponentsMSFT"> + <member values="XR_TYPE_SCENE_MARKERS_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>sceneMarkerCapacityInput</name></member> + <member optional="true" len="sceneMarkerCapacityInput"><type>XrSceneMarkerMSFT</type>* <name>sceneMarkers</name></member> + </type> + <type category="struct" name="XrSceneMarkerTypeFilterMSFT" structextends="XrSceneComponentsGetInfoMSFT"> + <member values="XR_TYPE_SCENE_MARKER_TYPE_FILTER_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>markerTypeCount</name></member> + <member optional="true" len="markerTypeCount"><type>XrSceneMarkerTypeMSFT</type>* <name>markerTypes</name></member> + </type> + <type category="struct" name="XrSceneMarkerQRCodeMSFT" returnedonly="true"> + <member><type>XrSceneMarkerQRCodeSymbolTypeMSFT</type> <name>symbolType</name></member> + <member><type>uint8_t</type> <name>version</name></member> + </type> + <type category="struct" name="XrSceneMarkerQRCodesMSFT" structextends="XrSceneComponentsMSFT"> + <member values="XR_TYPE_SCENE_MARKER_QR_CODES_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>qrCodeCapacityInput</name></member> + <member optional="true" len="qrCodeCapacityInput"><type>XrSceneMarkerQRCodeMSFT</type>* <name>qrCodes</name></member> + </type> + + <!-- XR_FB_color_space structs --> + <type name="XrColorSpaceFB" category="enum"/> + <type category="struct" name="XrSystemColorSpacePropertiesFB" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_COLOR_SPACE_PROPERTIES_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrColorSpaceFB</type> <name>colorSpace</name></member> + </type> + + <!-- XR_FB_spatial_entity structs --> + <type category="struct" name="XrSystemSpatialEntityPropertiesFB" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_SPATIAL_ENTITY_PROPERTIES_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSpatialEntity</name></member> + </type> + <type category="struct" name="XrSpatialAnchorCreateInfoFB"> + <member values="XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrPosef</type> <name>poseInSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrSpaceComponentStatusSetInfoFB"> + <member values="XR_TYPE_SPACE_COMPONENT_STATUS_SET_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpaceComponentTypeFB</type> <name>componentType</name></member> + <member><type>XrBool32</type> <name>enabled</name></member> + <member><type>XrDuration</type> <name>timeout</name></member> + </type> + <type category="struct" name="XrSpaceComponentStatusFB" returnedonly="true"> + <member values="XR_TYPE_SPACE_COMPONENT_STATUS_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>enabled</name></member> + <member><type>XrBool32</type> <name>changePending</name></member> + </type> + <type category="struct" name="XrEventDataSpatialAnchorCreateCompleteFB" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPATIAL_ANCHOR_CREATE_COMPLETE_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + </type> + <type category="struct" name="XrEventDataSpaceSetStatusCompleteFB" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPACE_SET_STATUS_COMPLETE_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + <member><type>XrSpaceComponentTypeFB</type> <name>componentType</name></member> + <member><type>XrBool32</type> <name>enabled</name></member> + </type> + + <!-- XR_FB_foveation structs --> + <type category="struct" name="XrFoveationProfileCreateInfoFB"> + <member values="XR_TYPE_FOVEATION_PROFILE_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrSwapchainCreateInfoFoveationFB" structextends="XrSwapchainCreateInfo"> + <member values="XR_TYPE_SWAPCHAIN_CREATE_INFO_FOVEATION_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrSwapchainCreateFoveationFlagsFB</type> <name>flags</name></member> + </type> + <type category="struct" name="XrSwapchainStateFoveationFB" parentstruct="XrSwapchainStateBaseHeaderFB"> + <member values="XR_TYPE_SWAPCHAIN_STATE_FOVEATION_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrSwapchainStateFoveationFlagsFB</type> <name>flags</name></member> + <member><type>XrFoveationProfileFB</type> <name>profile</name></member> + </type> + + <!-- XR_FB_foveation_vulkan structs --> + <type category="struct" name="XrSwapchainImageFoveationVulkanFB" structextends="XrSwapchainImageVulkanKHR" returnedonly="true"> + <member values="XR_TYPE_SWAPCHAIN_IMAGE_FOVEATION_VULKAN_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>VkImage</type> <name>image</name></member> + <member><type>uint32_t</type> <name>width</name></member> + <member><type>uint32_t</type> <name>height</name></member> + </type> + + <!-- XR_FB_foveation_configuration structs --> + <type name="XrFoveationLevelFB" category="enum"/> + <type name="XrFoveationDynamicFB" category="enum"/> + <type category="struct" name="XrFoveationLevelProfileCreateInfoFB" structextends="XrFoveationProfileCreateInfoFB"> + <member values="XR_TYPE_FOVEATION_LEVEL_PROFILE_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrFoveationLevelFB</type> <name>level</name></member> + <member><type>float</type> <name>verticalOffset</name></member> + <member><type>XrFoveationDynamicFB</type> <name>dynamic</name></member> + </type> + + <!-- XR_META_foveation_eye_tracked structs --> + <type category="struct" name="XrFoveationEyeTrackedProfileCreateInfoMETA" structextends="XrFoveationLevelProfileCreateInfoFB"> + <member values="XR_TYPE_FOVEATION_EYE_TRACKED_PROFILE_CREATE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrFoveationEyeTrackedProfileCreateFlagsMETA</type> <name>flags</name></member> + </type> + <type category="struct" name="XrFoveationEyeTrackedStateMETA" returnedonly="true"> + <member values="XR_TYPE_FOVEATION_EYE_TRACKED_STATE_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrVector2f</type> <name>foveationCenter</name>[<enum>XR_FOVEATION_CENTER_SIZE_META</enum>]</member> + <member><type>XrFoveationEyeTrackedStateFlagsMETA</type> <name>flags</name></member> + </type> + <type category="struct" name="XrSystemFoveationEyeTrackedPropertiesMETA" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_FOVEATION_EYE_TRACKED_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsFoveationEyeTracked</name></member> + </type> + + <!-- XR_FB_hand_tracking_mesh structs --> + <type category="struct" name="XrVector4sFB"> + <member><type>int16_t</type> <name>x</name></member> + <member><type>int16_t</type> <name>y</name></member> + <member><type>int16_t</type> <name>z</name></member> + <member><type>int16_t</type> <name>w</name></member> + </type> + <type category="struct" name="XrHandTrackingMeshFB"> + <member values="XR_TYPE_HAND_TRACKING_MESH_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>jointCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>jointCountOutput</name></member> + <member optional="true" len="jointCapacityInput"><type>XrPosef</type>* <name>jointBindPoses</name></member> + <member optional="true" len="jointCapacityInput"><type>float</type>* <name>jointRadii</name></member> + <member optional="true" len="jointCapacityInput"><type>XrHandJointEXT</type>* <name>jointParents</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCountOutput</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector3f</type>* <name>vertexPositions</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector3f</type>* <name>vertexNormals</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector2f</type>* <name>vertexUVs</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector4sFB</type>* <name>vertexBlendIndices</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector4f</type>* <name>vertexBlendWeights</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCountOutput</name></member> + <member optional="true" len="indexCapacityInput"><type>int16_t</type>* <name>indices</name></member> + </type> + <type category="struct" name="XrHandTrackingScaleFB" returnedonly="true" structextends="XrHandJointLocationsEXT"> + <member values="XR_TYPE_HAND_TRACKING_SCALE_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>float</type> <name>sensorOutput</name></member> + <member><type>float</type> <name>currentOutput</name></member> + <member><type>XrBool32</type> <name>overrideHandScale</name></member> + <member optional="true"><type>float</type> <name>overrideValueInput</name></member> + </type> + + <!-- XR_FB_hand_tracking_aim structs --> + <type category="struct" name="XrHandTrackingAimStateFB" returnedonly="true" structextends="XrHandJointLocationsEXT"> + <member values="XR_TYPE_HAND_TRACKING_AIM_STATE_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrHandTrackingAimFlagsFB</type> <name>status</name></member> + <member><type>XrPosef</type> <name>aimPose</name></member> + <member><type>float</type> <name>pinchStrengthIndex</name></member> + <member><type>float</type> <name>pinchStrengthMiddle</name></member> + <member><type>float</type> <name>pinchStrengthRing</name></member> + <member><type>float</type> <name>pinchStrengthLittle</name></member> + </type> + + <!-- XR_FB_hand_tracking_capsules structs --> + <type category="struct" name="XrHandCapsuleFB" returnedonly="true"> + <member><type>XrVector3f</type> <name>points</name>[<enum>XR_HAND_TRACKING_CAPSULE_POINT_COUNT_FB</enum>]</member> + <member><type>float</type> <name>radius</name></member> + <member><type>XrHandJointEXT</type> <name>joint</name></member> + </type> + <type category="struct" name="XrHandTrackingCapsulesStateFB" returnedonly="true" structextends="XrHandJointLocationsEXT"> + <member values="XR_TYPE_HAND_TRACKING_CAPSULES_STATE_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrHandCapsuleFB</type> <name>capsules</name>[<enum>XR_HAND_TRACKING_CAPSULE_COUNT_FB</enum>]</member> + </type> + + <!-- XR_FB_render_model structs --> + <type category="struct" name="XrRenderModelPathInfoFB"> + <member values="XR_TYPE_RENDER_MODEL_PATH_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrPath</type> <name>path</name></member> + </type> + <type category="struct" name="XrRenderModelPropertiesFB"> + <member values="XR_TYPE_RENDER_MODEL_PROPERTIES_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>vendorId</name></member> + <member><type>char</type> <name>modelName</name>[<enum>XR_MAX_RENDER_MODEL_NAME_SIZE_FB</enum>]</member> + <member><type>XrRenderModelKeyFB</type> <name>modelKey</name></member> + <member><type>uint32_t</type> <name>modelVersion</name></member> + <member><type>XrRenderModelFlagsFB</type> <name>flags</name></member> + </type> + <type category="struct" name="XrRenderModelCapabilitiesRequestFB" structextends="XrRenderModelPropertiesFB"> + <member values="XR_TYPE_RENDER_MODEL_CAPABILITIES_REQUEST_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrRenderModelFlagsFB</type> <name>flags</name></member> + </type> + <type category="struct" name="XrRenderModelBufferFB"> + <member values="XR_TYPE_RENDER_MODEL_BUFFER_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>bufferCountOutput</name></member> + <member optional="true" len="bufferCapacityInput"><type>uint8_t</type>* <name>buffer</name></member> + </type> + <type category="struct" name="XrRenderModelLoadInfoFB"> + <member values="XR_TYPE_RENDER_MODEL_LOAD_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrRenderModelKeyFB</type> <name>modelKey</name></member> + </type> + <type category="struct" name="XrSystemRenderModelPropertiesFB" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_RENDER_MODEL_PROPERTIES_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsRenderModelLoading</name></member> + </type> + + <!-- XR_FB_spatial_entity_query structs --> + <type category="struct" name="XrSpaceQueryInfoBaseHeaderFB"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrSpaceFilterInfoBaseHeaderFB"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrSpaceQueryInfoFB" parentstruct="XrSpaceQueryInfoBaseHeaderFB"> + <member values="XR_TYPE_SPACE_QUERY_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpaceQueryActionFB</type> <name>queryAction</name></member> + <member><type>uint32_t</type> <name>maxResultCount</name></member> + <member><type>XrDuration</type> <name>timeout</name></member> + <member optional="true">const <type>XrSpaceFilterInfoBaseHeaderFB</type>* <name>filter</name></member> + <member optional="true">const <type>XrSpaceFilterInfoBaseHeaderFB</type>* <name>excludeFilter</name></member> + </type> + <type category="struct" name="XrSpaceStorageLocationFilterInfoFB" structextends="XrSpaceFilterInfoBaseHeaderFB"> + <member values="XR_TYPE_SPACE_STORAGE_LOCATION_FILTER_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpaceStorageLocationFB</type> <name>location</name></member> + </type> + <type category="struct" name="XrSpaceUuidFilterInfoFB" parentstruct="XrSpaceFilterInfoBaseHeaderFB"> + <member values="XR_TYPE_SPACE_UUID_FILTER_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>uuidCount</name></member> + <member len="uuidCount"><type>XrUuidEXT</type>* <name>uuids</name></member> + </type> + <type category="struct" name="XrSpaceComponentFilterInfoFB" parentstruct="XrSpaceFilterInfoBaseHeaderFB"> + <member values="XR_TYPE_SPACE_COMPONENT_FILTER_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpaceComponentTypeFB</type> <name>componentType</name></member> + </type> + <type category="struct" name="XrSpaceQueryResultFB" returnedonly="true"> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + </type> + <type category="struct" name="XrSpaceQueryResultsFB"> + <member values="XR_TYPE_SPACE_QUERY_RESULTS_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>resultCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>resultCountOutput</name></member> + <member optional="true" len="resultCapacityInput"><type>XrSpaceQueryResultFB</type>* <name>results</name></member> + </type> + <type category="struct" name="XrEventDataSpaceQueryResultsAvailableFB" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPACE_QUERY_RESULTS_AVAILABLE_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + </type> + <type category="struct" name="XrEventDataSpaceQueryCompleteFB" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPACE_QUERY_COMPLETE_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + + <!-- XR_FB_spatial_entity_storage structs --> + <type category="struct" name="XrSpaceSaveInfoFB"> + <member values="XR_TYPE_SPACE_SAVE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrSpaceStorageLocationFB</type> <name>location</name></member> + <member><type>XrSpacePersistenceModeFB</type> <name>persistenceMode</name></member> + </type> + <type category="struct" name="XrSpaceEraseInfoFB"> + <member values="XR_TYPE_SPACE_ERASE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrSpaceStorageLocationFB</type> <name>location</name></member> + </type> + <type category="struct" name="XrEventDataSpaceSaveCompleteFB" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPACE_SAVE_COMPLETE_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + <member><type>XrSpaceStorageLocationFB</type> <name>location</name></member> + </type> + <type category="struct" name="XrEventDataSpaceEraseCompleteFB" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPACE_ERASE_COMPLETE_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + <member><type>XrSpaceStorageLocationFB</type> <name>location</name></member> + </type> + + <!-- XR_FB_spatial_entity_sharing structs --> + <type category="struct" name="XrSpaceShareInfoFB"> + <member values="XR_TYPE_SPACE_SHARE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>spaceCount</name></member> + <member len="spaceCount"><type>XrSpace</type>* <name>spaces</name></member> + <member><type>uint32_t</type> <name>userCount</name></member> + <member len="userCount"><type>XrSpaceUserFB</type>* <name>users</name></member> + </type> + <type category="struct" name="XrEventDataSpaceShareCompleteFB" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPACE_SHARE_COMPLETE_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + + <!-- XR_FB_spatial_entity_storage_batch structs --> + <type category="struct" name="XrSpaceListSaveInfoFB"> + <member values="XR_TYPE_SPACE_LIST_SAVE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>spaceCount</name></member> + <member len="spaceCount"><type>XrSpace</type>* <name>spaces</name></member> + <member><type>XrSpaceStorageLocationFB</type> <name>location</name></member> + </type> + <type category="struct" name="XrEventDataSpaceListSaveCompleteFB" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPACE_LIST_SAVE_COMPLETE_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + + <!-- XR_FB_spatial_entity_container structs --> + <type category="struct" name="XrSpaceContainerFB"> + <member values="XR_TYPE_SPACE_CONTAINER_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>uuidCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>uuidCountOutput</name></member> + <member optional="true" len="uuidCapacityInput"><type>XrUuidEXT</type>* <name>uuids</name></member> + </type> + + <!-- XR_META_spatial_entity_mesh structs --> + <type category="struct" name="XrSpaceTriangleMeshGetInfoMETA"> + <member values="XR_TYPE_SPACE_TRIANGLE_MESH_GET_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrSpaceTriangleMeshMETA" returnedonly="true"> + <member values="XR_TYPE_SPACE_TRIANGLE_MESH_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCountOutput</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector3f</type>* <name>vertices</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCountOutput</name></member> + <member optional="true" len="indexCapacityInput"><type>uint32_t</type>* <name>indices</name></member> + </type> + + <!-- XR_META_spatial_entity_room_mesh structs --> + <type category="struct" name="XrRoomMeshFaceMETA"> + <member><type>XrUuid</type> <name>uuid</name></member> + <member optional="true"><type>XrUuid</type> <name>parentUuid</name></member> + <member><type>XrSemanticLabelMETA</type> <name>semanticLabel</name></member> + </type> + + <type category="struct" name="XrRoomMeshFaceIndicesMETA"> + <member values="XR_TYPE_ROOM_MESH_FACE_INDICES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCountOutput</name></member> + <member optional="true" len="indexCapacityInput"><type>uint32_t</type>* <name>indices</name></member> + </type> + + <type category="struct" name="XrSpaceRoomMeshGetInfoMETA"> + <member values="XR_TYPE_SPACE_ROOM_MESH_GET_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>recognizedSemanticLabelCount</name></member> + <member optional="true" len="recognizedSemanticLabelCount">const <type>XrSemanticLabelMETA</type>* <name>recognizedSemanticLabels</name></member> + </type> + + <type category="struct" name="XrRoomMeshMETA"> + <member values="XR_TYPE_ROOM_MESH_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCountOutput</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector3f</type>* <name>vertices</name></member> + <member optional="true"><type>uint32_t</type> <name>faceCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>faceCountOutput</name></member> + <member optional="true" len="faceCapacityInput"><type>XrRoomMeshFaceMETA</type>* <name>faces</name></member> + </type> + + <!-- XR_META_boundary_visibility structs --> + <type category="struct" name="XrSystemBoundaryVisibilityPropertiesMETA" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_BOUNDARY_VISIBILITY_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsBoundaryVisibility</name></member> + </type> + + <type category="struct" name="XrEventDataBoundaryVisibilityChangedMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_BOUNDARY_VISIBILITY_CHANGED_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBoundaryVisibilityMETA</type> <name>boundaryVisibility</name></member> + </type> + + <!-- XR_FB_scene structs --> + <type category="struct" name="XrExtent3DfFB" alias="XrExtent3Df"/> + + <type category="struct" name="XrOffset3DfFB"> + <member><type>float</type> <name>x</name></member> + <member><type>float</type> <name>y</name></member> + <member><type>float</type> <name>z</name></member> + </type> + + <type category="struct" name="XrRect3DfFB"> + <member><type>XrOffset3DfFB</type> <name>offset</name></member> + <member><type>XrExtent3DfFB</type> <name>extent</name></member> + </type> + + <type category="struct" name="XrSemanticLabelsFB"> + <member values="XR_TYPE_SEMANTIC_LABELS_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>bufferCountOutput</name></member> + <member optional="true" len="bufferCapacityInput"><type>char</type>* <name>buffer</name></member> + </type> + <type category="struct" name="XrRoomLayoutFB"> + <member values="XR_TYPE_ROOM_LAYOUT_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrUuidEXT</type> <name>floorUuid</name></member> + <member><type>XrUuidEXT</type> <name>ceilingUuid</name></member> + <member optional="true"><type>uint32_t</type> <name>wallUuidCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>wallUuidCountOutput</name></member> + <member optional="true" len="wallUuidCapacityInput"><type>XrUuidEXT</type>* <name>wallUuids</name></member> + </type> + <type category="struct" name="XrBoundary2DFB"> + <member values="XR_TYPE_BOUNDARY_2D_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCountOutput</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector2f</type>* <name>vertices</name></member> + </type> + <type category="struct" name="XrSemanticLabelsSupportInfoFB" structextends="XrSemanticLabelsFB"> + <member values="XR_TYPE_SEMANTIC_LABELS_SUPPORT_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrSemanticLabelsSupportFlagsFB</type> <name>flags</name></member> + <member len="null-terminated">const <type>char</type>* <name>recognizedLabels</name></member> + </type> + + <!-- XR_FB_scene_capture structs --> + <type category="struct" name="XrSceneCaptureRequestInfoFB"> + <member values="XR_TYPE_SCENE_CAPTURE_REQUEST_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>requestByteCount</name></member> + <member optional="true" len="requestByteCount">const <type>char</type>* <name>request</name></member> + </type> + <type category="struct" name="XrEventDataSceneCaptureCompleteFB" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SCENE_CAPTURE_COMPLETE_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + + <!-- XR_FB_keyboard_tracking structs --> + <type category="struct" name="XrSystemKeyboardTrackingPropertiesFB" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_KEYBOARD_TRACKING_PROPERTIES_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsKeyboardTracking</name></member> + </type> + <type category="struct" name="XrKeyboardTrackingDescriptionFB" returnedonly="true"> + <member><type>uint64_t</type> <name>trackedKeyboardId</name></member> + <member><type>XrVector3f</type> <name>size</name></member> + <member><type>XrKeyboardTrackingFlagsFB</type> <name>flags</name></member> + <member><type>char</type> <name>name</name>[<enum>XR_MAX_KEYBOARD_TRACKING_NAME_SIZE_FB</enum>]</member> + </type> + <type category="struct" name="XrKeyboardSpaceCreateInfoFB"> + <member values="XR_TYPE_KEYBOARD_SPACE_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint64_t</type> <name>trackedKeyboardId</name></member> + </type> + <type category="struct" name="XrKeyboardTrackingQueryFB"> + <member values="XR_TYPE_KEYBOARD_TRACKING_QUERY_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrKeyboardTrackingQueryFlagsFB</type> <name>flags</name></member> + </type> + + <!-- XR_META_colocation_discovery --> + <type category="struct" name="XrSystemColocationDiscoveryPropertiesMETA" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_COLOCATION_DISCOVERY_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsColocationDiscovery</name></member> + </type> + <type category="struct" name="XrColocationAdvertisementStartInfoMETA"> + <member values="XR_TYPE_COLOCATION_ADVERTISEMENT_START_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>bufferSize</name></member> + <member len="bufferSize"><type>uint8_t</type>* <name>buffer</name></member> + </type> + <type category="struct" name="XrColocationAdvertisementStopInfoMETA"> + <member values="XR_TYPE_COLOCATION_ADVERTISEMENT_STOP_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrColocationDiscoveryStartInfoMETA"> + <member values="XR_TYPE_COLOCATION_DISCOVERY_START_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrColocationDiscoveryStopInfoMETA"> + <member values="XR_TYPE_COLOCATION_DISCOVERY_STOP_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrEventDataStartColocationAdvertisementCompleteMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_START_COLOCATION_ADVERTISEMENT_COMPLETE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>advertisementRequestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + <member><type>XrUuid</type> <name>advertisementUuid</name></member> + </type> + <type category="struct" name="XrEventDataColocationAdvertisementCompleteMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_COLOCATION_ADVERTISEMENT_COMPLETE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>advertisementRequestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + <type category="struct" name="XrEventDataStopColocationAdvertisementCompleteMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_STOP_COLOCATION_ADVERTISEMENT_COMPLETE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + <type category="struct" name="XrEventDataStartColocationDiscoveryCompleteMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_START_COLOCATION_DISCOVERY_COMPLETE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>discoveryRequestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + <type category="struct" name="XrEventDataColocationDiscoveryResultMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_COLOCATION_DISCOVERY_RESULT_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>discoveryRequestId</name></member> + <member><type>XrUuid</type> <name>advertisementUuid</name></member> + <member><type>uint32_t</type> <name>bufferSize</name></member> + <member len="bufferSize"><type>uint8_t</type> <name>buffer</name>[<enum>XR_MAX_COLOCATION_DISCOVERY_BUFFER_SIZE_META</enum>]</member> + </type> + <type category="struct" name="XrEventDataColocationDiscoveryCompleteMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_COLOCATION_DISCOVERY_COMPLETE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>discoveryRequestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + <type category="struct" name="XrEventDataStopColocationDiscoveryCompleteMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_STOP_COLOCATION_DISCOVERY_COMPLETE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + + <!-- XR_META_spatial_entity_sharing --> + <type category="struct" name="XrSystemSpatialEntitySharingPropertiesMETA" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_SPATIAL_ENTITY_SHARING_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSpatialEntitySharing</name></member> + </type> + <type category="struct" name="XrShareSpacesRecipientBaseHeaderMETA"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrShareSpacesInfoMETA"> + <member values="XR_TYPE_SHARE_SPACES_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>spaceCount</name></member> + <member len="spaceCount"><type>XrSpace</type>* <name>spaces</name></member> + <member>const <type>XrShareSpacesRecipientBaseHeaderMETA</type>* <name>recipientInfo</name></member> + </type> + <type category="struct" name="XrEventDataShareSpacesCompleteMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SHARE_SPACES_COMPLETE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + + <!-- XR_META_spatial_entity_group_sharing --> + <type category="struct" name="XrShareSpacesRecipientGroupsMETA" parentstruct="XrShareSpacesRecipientBaseHeaderMETA"> + <member values="XR_TYPE_SHARE_SPACES_RECIPIENT_GROUPS_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>groupCount</name></member> + <member len="groupCount"><type>XrUuid</type>* <name>groups</name></member> + </type> + <type category="struct" name="XrSpaceGroupUuidFilterInfoMETA" structextends="XrSpaceQueryInfoBaseHeaderFB"> + <member values="XR_TYPE_SPACE_GROUP_UUID_FILTER_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrUuid</type> <name>groupUuid</name></member> + </type> + <type category="struct" name="XrSystemSpatialEntityGroupSharingPropertiesMETA" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_SPATIAL_ENTITY_GROUP_SHARING_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSpatialEntityGroupSharing</name></member> + </type> + + <!-- XR_VARJO_composition_layer_depth_test --> + <type category="struct" name="XrCompositionLayerDepthTestVARJO" structextends="XrCompositionLayerProjection"> + <member values="XR_TYPE_COMPOSITION_LAYER_DEPTH_TEST_VARJO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>depthTestRangeNearZ</name></member> + <member><type>float</type> <name>depthTestRangeFarZ</name></member> + </type> + + <!-- XR_VARJO_foveated_rendering --> + <type category="struct" name="XrViewLocateFoveatedRenderingVARJO" structextends="XrViewLocateInfo"> + <member values="XR_TYPE_VIEW_LOCATE_FOVEATED_RENDERING_VARJO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>foveatedRenderingActive</name></member> + </type> + + <type category="struct" name="XrFoveatedViewConfigurationViewVARJO" structextends="XrViewConfigurationView"> + <member values="XR_TYPE_FOVEATED_VIEW_CONFIGURATION_VIEW_VARJO"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>foveatedRenderingActive</name></member> + </type> + + <type category="struct" name="XrSystemFoveatedRenderingPropertiesVARJO" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_FOVEATED_RENDERING_PROPERTIES_VARJO"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsFoveatedRendering</name></member> + </type> + + <!-- XR_MSFT_composition_layer_reprojection --> + <type name="XrReprojectionModeMSFT" category="enum"/> + <type category="struct" name="XrCompositionLayerReprojectionInfoMSFT" structextends="XrCompositionLayerProjection"> + <member values="XR_TYPE_COMPOSITION_LAYER_REPROJECTION_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrReprojectionModeMSFT</type> <name>reprojectionMode</name></member> + </type> + <type category="struct" name="XrCompositionLayerReprojectionPlaneOverrideMSFT" structextends="XrCompositionLayerProjection"> + <member values="XR_TYPE_COMPOSITION_LAYER_REPROJECTION_PLANE_OVERRIDE_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrVector3f</type> <name>position</name></member> + <member><type>XrVector3f</type> <name>normal</name></member> + <member><type>XrVector3f</type> <name>velocity</name></member> + </type> + + <!-- XR_FB_triangle_mesh --> + <type category="struct" name="XrTriangleMeshCreateInfoFB"> + <member values="XR_TYPE_TRIANGLE_MESH_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrTriangleMeshFlagsFB</type> <name>flags</name></member> + <member><type>XrWindingOrderFB</type> <name>windingOrder</name></member> + <member><type>uint32_t</type> <name>vertexCount</name></member> + <member optional="true" noautovalidity="true">const <type>XrVector3f</type>* <name>vertexBuffer</name></member> + <member><type>uint32_t</type> <name>triangleCount</name></member> + <member optional="true" noautovalidity="true">const <type>uint32_t</type>* <name>indexBuffer</name></member> + </type> + + <!-- XR_FB_passthrough --> + <type category="struct" name="XrSystemPassthroughPropertiesFB" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_PASSTHROUGH_PROPERTIES_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsPassthrough</name></member> + </type> + <type category="struct" name="XrSystemPassthroughProperties2FB" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_PASSTHROUGH_PROPERTIES2_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrPassthroughCapabilityFlagsFB</type> <name>capabilities</name></member> + </type> + <type category="struct" name="XrPassthroughCreateInfoFB"> + <member values="XR_TYPE_PASSTHROUGH_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrPassthroughFlagsFB</type> <name>flags</name></member> + </type> + <type category="struct" name="XrPassthroughLayerCreateInfoFB"> + <member values="XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPassthroughFB</type> <name>passthrough</name></member> + <member optional="true"><type>XrPassthroughFlagsFB</type> <name>flags</name></member> + <member><type>XrPassthroughLayerPurposeFB</type> <name>purpose</name></member> + </type> + <type category="struct" name="XrCompositionLayerPassthroughFB" parentstruct="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCompositionLayerFlags</type> <name>flags</name></member> + <member optional="true"><type>XrSpace</type> <name>space</name></member> + <member><type>XrPassthroughLayerFB</type> <name>layerHandle</name></member> + </type> + <type category="struct" name="XrGeometryInstanceCreateInfoFB"> + <member values="XR_TYPE_GEOMETRY_INSTANCE_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPassthroughLayerFB</type> <name>layer</name></member> + <member><type>XrTriangleMeshFB</type> <name>mesh</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrVector3f</type> <name>scale</name></member> + </type> + <type category="struct" name="XrGeometryInstanceTransformFB"> + <member values="XR_TYPE_GEOMETRY_INSTANCE_TRANSFORM_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrVector3f</type> <name>scale</name></member> + </type> + <type category="struct" name="XrPassthroughStyleFB"> + <member values="XR_TYPE_PASSTHROUGH_STYLE_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>textureOpacityFactor</name></member> + <member><type>XrColor4f</type> <name>edgeColor</name></member> + </type> + <type category="struct" name="XrPassthroughColorMapMonoToRgbaFB" structextends="XrPassthroughStyleFB"> + <member values="XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_RGBA_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrColor4f</type> <name>textureColorMap</name>[<enum>XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB</enum>]</member> + </type> + <type category="struct" name="XrPassthroughColorMapMonoToMonoFB" structextends="XrPassthroughStyleFB"> + <member values="XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_MONO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint8_t</type> <name>textureColorMap</name>[<enum>XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB</enum>]</member> + </type> + <type category="struct" name="XrPassthroughBrightnessContrastSaturationFB" structextends="XrPassthroughStyleFB"> + <member values="XR_TYPE_PASSTHROUGH_BRIGHTNESS_CONTRAST_SATURATION_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>brightness</name></member> + <member><type>float</type> <name>contrast</name></member> + <member><type>float</type> <name>saturation</name></member> + </type> + <type category="struct" name="XrEventDataPassthroughStateChangedFB" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_PASSTHROUGH_STATE_CHANGED_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPassthroughStateChangedFlagsFB</type> <name>flags</name></member> + </type> + + <!-- XR_FB_passthrough_keyboard_hands --> + <type category="struct" name="XrPassthroughKeyboardHandsIntensityFB"> + <member values="XR_TYPE_PASSTHROUGH_KEYBOARD_HANDS_INTENSITY_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>leftHandIntensity</name></member> + <member><type>float</type> <name>rightHandIntensity</name></member> + </type> + + <!-- XR_META_local_dimming --> + <type category="struct" name="XrLocalDimmingFrameEndInfoMETA" structextends="XrFrameEndInfo"> + <member values="XR_TYPE_LOCAL_DIMMING_FRAME_END_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrLocalDimmingModeMETA</type> <name>localDimmingMode</name></member> + </type> + + <!-- XR_MSFT_spatial_anchor_persistence --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSpatialAnchorStoreConnectionMSFT</name>)</type> + + <type category="struct" name="XrSpatialAnchorPersistenceNameMSFT"> + <member><type>char</type> <name>name</name>[<enum>XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_MSFT</enum>]</member> + </type> + <type category="struct" name="XrSpatialAnchorPersistenceInfoMSFT"> + <member values="XR_TYPE_SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialAnchorPersistenceNameMSFT</type> <name>spatialAnchorPersistenceName</name></member> + <member><type>XrSpatialAnchorMSFT</type> <name>spatialAnchor</name></member> + </type> + <type category="struct" name="XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT"> + <member values="XR_TYPE_SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialAnchorStoreConnectionMSFT</type> <name>spatialAnchorStore</name></member> + <member><type>XrSpatialAnchorPersistenceNameMSFT</type> <name>spatialAnchorPersistenceName</name></member> + </type> + + <!-- XR_BD_body_tracking --> + <type category="struct" name="XrSystemBodyTrackingPropertiesBD" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsBodyTracking</name></member> + </type> + <type category="struct" name="XrBodyTrackerCreateInfoBD"> + <member values="XR_TYPE_BODY_TRACKER_CREATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBodyJointSetBD</type> <name>jointSet</name></member> + </type> + <type category="struct" name="XrBodyJointsLocateInfoBD"> + <member values="XR_TYPE_BODY_JOINTS_LOCATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrBodyJointLocationBD"> + <member optional="true"><type>XrSpaceLocationFlags</type> <name>locationFlags</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrBodyJointLocationsBD"> + <member values="XR_TYPE_BODY_JOINT_LOCATIONS_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>allJointPosesTracked</name></member> + <member><type>uint32_t</type> <name>jointLocationCount</name></member> + <member len="jointLocationCount"><type>XrBodyJointLocationBD</type>* <name>jointLocations</name></member> + </type> + + <!-- XR_BD_future_progress --> + <type category="struct" name="XrFuturePollResultProgressBD" structextends="XrFuturePollResultEXT" returnedonly="true"> + <member values="XR_TYPE_FUTURE_POLL_RESULT_PROGRESS_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>isSupported</name></member> + <member><type>uint32_t</type> <name>progressPercentage</name></member> + </type> + + <!-- XR_BD_body_tracking_auxiliary_metrics --> + <type category="struct" name="XrBodyTrackingPostureDataBD" structextends="XrBodyJointLocationsBD"> + <member values="XR_TYPE_BODY_TRACKING_POSTURE_DATA_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>postureCount</name></member> + <member len="postureCount"><type>XrBodyTrackingPostureBD</type>* <name>postureData</name></member> + </type> + <type category="struct" name="XrBodyJointVelocityBD"> + <member optional="true"><type>XrSpaceVelocityFlags</type> <name>velocityFlags</name></member> + <member><type>XrVector3f</type> <name>linearVelocity</name></member> + <member><type>XrVector3f</type> <name>angularVelocity</name></member> + </type> + <type category="struct" name="XrBodyJointVelocitiesBD" structextends="XrBodyJointLocationsBD"> + <member values="XR_TYPE_BODY_JOINT_VELOCITIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>velocityCount</name></member> + <member len="velocityCount"><type>XrBodyJointVelocityBD</type>* <name>velocities</name></member> + </type> + <type category="struct" name="XrBodyJointAccelerationBD"> + <member optional="true"><type>XrSpaceAccelerationFlagsBD</type> <name>accelerationFlags</name></member> + <member><type>XrVector3f</type> <name>linearAcceleration</name></member> + <member><type>XrVector3f</type> <name>angularAcceleration</name></member> + </type> + <type category="struct" name="XrBodyJointAccelerationsBD" structextends="XrBodyJointLocationsBD"> + <member values="XR_TYPE_BODY_JOINT_ACCELERATIONS_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>accelerationCount</name></member> + <member len="accelerationCount"><type>XrBodyJointAccelerationBD</type>* <name>accelerations</name></member> + </type> + <type category="struct" name="XrBodyTrackingStateBD"> + <member values="XR_TYPE_BODY_TRACKING_STATE_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBodyTrackingStatusBD</type> <name>status</name></member> + <member><type>XrBodyTrackingMessageBD</type> <name>message</name></member> + </type> + + <!-- XR_HTC_facial_tracking --> + <type category="struct" name="XrFacialTrackerCreateInfoHTC"> + <member values="XR_TYPE_FACIAL_TRACKER_CREATE_INFO_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrFacialTrackingTypeHTC</type> <name>facialTrackingType</name></member> + </type> + <type category="struct" name="XrSystemFacialTrackingPropertiesHTC" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_FACIAL_TRACKING_PROPERTIES_HTC"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportEyeFacialTracking</name></member> + <member><type>XrBool32</type> <name>supportLipFacialTracking</name></member> + </type> + <type category="struct" name="XrFacialExpressionsHTC"> + <member values="XR_TYPE_FACIAL_EXPRESSIONS_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>isActive</name></member> + <member><type>XrTime</type> <name>sampleTime</name></member> + <member><type>uint32_t</type> <name>expressionCount</name></member> + <member><type>float</type>* <name>expressionWeightings</name></member> + </type> + + <!-- XR_HTC_passthrough --> + <type category="struct" name="XrPassthroughCreateInfoHTC"> + <member values="XR_TYPE_PASSTHROUGH_CREATE_INFO_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPassthroughFormHTC</type> <name>form</name></member> + </type> + <type category="struct" name="XrPassthroughColorHTC"> + <member values="XR_TYPE_PASSTHROUGH_COLOR_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>alpha</name></member> + </type> + <type category="struct" name="XrPassthroughMeshTransformInfoHTC" structextends="XrCompositionLayerPassthroughHTC"> + <member values="XR_TYPE_PASSTHROUGH_MESH_TRANSFORM_INFO_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>vertexCount</name></member> + <member len="vertexCount">const <type>XrVector3f</type>* <name>vertices</name></member> + <member><type>uint32_t</type> <name>indexCount</name></member> + <member len="indexCount">const <type>uint32_t</type>* <name>indices</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrVector3f</type> <name>scale</name></member> + </type> + <type category="struct" name="XrCompositionLayerPassthroughHTC" parentstruct="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCompositionLayerFlags</type> <name>layerFlags</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrPassthroughHTC</type> <name>passthrough</name></member> + <member><type>XrPassthroughColorHTC</type> <name>color</name></member> + </type> + + <!-- XR_HTC_anchor --> + <type category="struct" name="XrSpatialAnchorCreateInfoHTC"> + <member values="XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrPosef</type> <name>poseInSpace</name></member> + <member><type>XrSpatialAnchorNameHTC</type> <name>name</name></member> + </type> + <type category="struct" name="XrSpatialAnchorNameHTC"> + <member><type>char</type> <name>name</name>[<enum>XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_HTC</enum>]</member> + </type> + <type category="struct" name="XrSystemAnchorPropertiesHTC" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_ANCHOR_PROPERTIES_HTC"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsAnchor</name></member> + </type> + + <!-- XR_HTCX_vive_tracker_interaction structs --> + <type category="struct" name="XrViveTrackerPathsHTCX" returnedonly="true"> + <member values="XR_TYPE_VIVE_TRACKER_PATHS_HTCX"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrPath</type> <name>persistentPath</name></member> + <member optional="true"><type>XrPath</type> <name>rolePath</name></member> + </type> + <type category="struct" name="XrEventDataViveTrackerConnectedHTCX" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_VIVE_TRACKER_CONNECTED_HTCX"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrViveTrackerPathsHTCX</type>* <name>paths</name></member> + </type> + + <!-- XR_HTC_body_tracking --> + <type category="struct" name="XrSystemBodyTrackingPropertiesHTC" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_HTC"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsBodyTracking</name></member> + </type> + <type category="struct" name="XrBodyTrackerCreateInfoHTC"> + <member values="XR_TYPE_BODY_TRACKER_CREATE_INFO_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBodyJointSetHTC</type> <name>bodyJointSet</name></member> + </type> + <type category="struct" name="XrBodySkeletonJointHTC"> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrBodySkeletonHTC"> + <member values="XR_TYPE_BODY_SKELETON_HTC"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>jointCount</name></member> + <member len="jointCount"><type>XrBodySkeletonJointHTC</type>* <name>joints</name></member> + </type> + <type category="struct" name="XrBodyJointsLocateInfoHTC"> + <member values="XR_TYPE_BODY_JOINTS_LOCATE_INFO_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrBodyJointLocationHTC" returnedonly="true"> + <member optional="true"><type>XrSpaceLocationFlags</type> <name>locationFlags</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrBodyJointLocationsHTC"> + <member values="XR_TYPE_BODY_JOINT_LOCATIONS_HTC"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrSpaceLocationFlags</type> <name>combinedLocationFlags</name></member> + <member><type>XrBodyJointConfidenceHTC</type> <name>confidenceLevel</name></member> + <member><type>uint32_t</type> <name>jointLocationCount</name></member> + <member len="jointLocationCount"><type>XrBodyJointLocationHTC</type>* <name>jointLocations</name></member> + <member><type>uint32_t</type> <name>skeletonGenerationId</name></member> + </type> + + <!-- XR_FB_space_warp --> + <type category="struct" name="XrCompositionLayerSpaceWarpInfoFB" structextends="XrCompositionLayerProjectionView"> + <member values="XR_TYPE_COMPOSITION_LAYER_SPACE_WARP_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrCompositionLayerSpaceWarpInfoFlagsFB</type> <name>layerFlags</name></member> + <member><type>XrSwapchainSubImage</type> <name>motionVectorSubImage</name></member> + <member><type>XrPosef</type> <name>appSpaceDeltaPose</name></member> + <member><type>XrSwapchainSubImage</type> <name>depthSubImage</name></member> + <member><type>float</type> <name>minDepth</name></member> + <member><type>float</type> <name>maxDepth</name></member> + <member><type>float</type> <name>nearZ</name></member> + <member><type>float</type> <name>farZ</name></member> + </type> + <type category="struct" name="XrSystemSpaceWarpPropertiesFB" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_SPACE_WARP_PROPERTIES_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>recommendedMotionVectorImageRectWidth</name></member> + <member><type>uint32_t</type> <name>recommendedMotionVectorImageRectHeight</name></member> + </type> + + + <!-- XR_VARJO_marker_tracking --> + <type category="struct" name="XrSystemMarkerTrackingPropertiesVARJO" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_VARJO"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsMarkerTracking</name></member> + </type> + + <type category="struct" name="XrEventDataMarkerTrackingUpdateVARJO" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_MARKER_TRACKING_UPDATE_VARJO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint64_t</type> <name>markerId</name></member> + <member><type>XrBool32</type> <name>isActive</name></member> + <member><type>XrBool32</type> <name>isPredicted</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <type category="struct" name="XrMarkerSpaceCreateInfoVARJO"> + <member values="XR_TYPE_MARKER_SPACE_CREATE_INFO_VARJO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint64_t</type> <name>markerId</name></member> + <member><type>XrPosef</type> <name>poseInMarkerSpace</name></member> + </type> + + <!-- XR_EXT_uuid --> + <type category="struct" name="XrUuidEXT" alias="XrUuid"/> + + <!-- XR_ML_global_dimmer --> + <type category="struct" name="XrGlobalDimmerFrameEndInfoML" structextends="XrFrameEndInfo"> + <member values="XR_TYPE_GLOBAL_DIMMER_FRAME_END_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>dimmerValue</name></member> + <member optional="true"><type>XrGlobalDimmerFrameEndInfoFlagsML</type> <name>flags</name></member> + </type> + + <!-- XR_ALMALENCE_digital_lens_control --> + <type category="struct" name="XrDigitalLensControlALMALENCE"> + <member values="XR_TYPE_DIGITAL_LENS_CONTROL_ALMALENCE"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrDigitalLensControlFlagsALMALENCE</type> <name>flags</name></member> + </type> + + <!-- XR_ULTRALEAP_hand_tracking_forearm --> + <type name="XrHandForearmJointULTRALEAP" category="enum"/> + + <!-- XR_FB_composition_layer_depth_test --> + <type name="XrCompareOpFB" category="enum"/> + + <!-- XR_FB_composition_layer_settings structs --> + <type category="struct" name="XrCompositionLayerSettingsFB" structextends="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_SETTINGS_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCompositionLayerSettingsFlagsFB</type> <name>layerFlags</name></member> + </type> + + <!-- XR_OCULUS_external_camera --> + <type category="struct" name="XrExternalCameraIntrinsicsOCULUS"> + <member><type>XrTime</type> <name>lastChangeTime</name></member> + <member><type>XrFovf</type> <name>fov</name></member> + <member><type>float</type> <name>virtualNearPlaneDistance</name></member> + <member><type>float</type> <name>virtualFarPlaneDistance</name></member> + <member><type>XrExtent2Di</type> <name>imageSensorPixelResolution</name></member> + </type> + + <type category="struct" name="XrExternalCameraExtrinsicsOCULUS"> + <member><type>XrTime</type> <name>lastChangeTime</name></member> + <member optional="true"><type>XrExternalCameraStatusFlagsOCULUS</type> <name>cameraStatusFlags</name></member> + <member><type>XrExternalCameraAttachedToDeviceOCULUS</type> <name>attachedToDevice</name></member> + <member><type>XrPosef</type> <name>relativePose</name></member> + </type> + + <type category="struct" name="XrExternalCameraOCULUS" returnedonly="true"> + <member values="XR_TYPE_EXTERNAL_CAMERA_OCULUS"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>char</type> <name>name</name>[<enum>XR_MAX_EXTERNAL_CAMERA_NAME_SIZE_OCULUS</enum>]</member> + <member><type>XrExternalCameraIntrinsicsOCULUS</type> <name>intrinsics</name></member> + <member><type>XrExternalCameraExtrinsicsOCULUS</type> <name>extrinsics</name></member> + </type> + + <!-- XR_META_performance_metrics --> + <type category="struct" name="XrPerformanceMetricsStateMETA"> + <member values="XR_TYPE_PERFORMANCE_METRICS_STATE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>enabled</name></member> + </type> + + <type category="struct" name="XrPerformanceMetricsCounterMETA"> + <member values="XR_TYPE_PERFORMANCE_METRICS_COUNTER_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrPerformanceMetricsCounterFlagsMETA</type> <name>counterFlags</name></member> + <member><type>XrPerformanceMetricsCounterUnitMETA</type> <name>counterUnit</name></member> + <member><type>uint32_t</type> <name>uintValue</name></member> + <member><type>float</type> <name>floatValue</name></member> + </type> + + <!-- XR_META_passthrough_preferences structs --> + <type category="struct" name="XrPassthroughPreferencesMETA" returnedonly="true"> + <member values="XR_TYPE_PASSTHROUGH_PREFERENCES_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPassthroughPreferenceFlagsMETA</type> <name>flags</name></member> + </type> + + <!-- XR_META_headset_id structs --> + <type category="struct" name="XrSystemHeadsetIdPropertiesMETA" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_HEADSET_ID_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrUuidEXT</type> <name>id</name></member> + </type> + + <!-- XR_META_spatial_entity_persistence structs --> + <type category="struct" name="XrSystemSpacePersistencePropertiesMETA" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_SPACE_PERSISTENCE_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSpacePersistence</name></member> + </type> + + <type category="struct" name="XrSpacesSaveInfoMETA"> + <member values="XR_TYPE_SPACES_SAVE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>spaceCount</name></member> + <member len="spaceCount"><type>XrSpace</type>* <name>spaces</name></member> + </type> + + <type category="struct" name="XrEventDataSpacesSaveResultMETA" returnedonly="true" parentstruct="XrEventDataBaseHeader"> + <member values="XR_TYPE_EVENT_DATA_SPACES_SAVE_RESULT_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + + <type category="struct" name="XrSpacesEraseInfoMETA"> + <member values="XR_TYPE_SPACES_ERASE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>spaceCount</name></member> + <member len="spaceCount" optional="true"><type>XrSpace</type>* <name>spaces</name></member> + <member optional="true"><type>uint32_t</type> <name>uuidCount</name></member> + <member len="uuidCount" optional="true"><type>XrUuidEXT</type>* <name>uuids</name></member> + </type> + + <type category="struct" name="XrEventDataSpacesEraseResultMETA" returnedonly="true" parentstruct="XrEventDataBaseHeader"> + <member values="XR_TYPE_EVENT_DATA_SPACES_ERASE_RESULT_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + + <!-- XR_META_spatial_entity_discovery structs --> + <type category="struct" name="XrSystemSpaceDiscoveryPropertiesMETA" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_SPACE_DISCOVERY_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSpaceDiscovery</name></member> + </type> + + <type category="struct" name="XrSpaceFilterBaseHeaderMETA"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrSpaceDiscoveryInfoMETA"> + <member values="XR_TYPE_SPACE_DISCOVERY_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>filterCount</name></member> + <member optional="true" len="filterCount">const <type>XrSpaceFilterBaseHeaderMETA</type>* const * <name>filters</name></member> + </type> + + <type category="struct" name="XrSpaceFilterUuidMETA" parentstruct="XrSpaceFilterBaseHeaderMETA"> + <member values="XR_TYPE_SPACE_FILTER_UUID_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>uuidCount</name></member> + <member len="uuidCount">const <type>XrUuidEXT</type>* <name>uuids</name></member> + </type> + + <type category="struct" name="XrSpaceFilterComponentMETA" parentstruct="XrSpaceFilterBaseHeaderMETA"> + <member values="XR_TYPE_SPACE_FILTER_COMPONENT_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpaceComponentTypeFB</type> <name>componentType</name></member> + </type> + + <type category="struct" name="XrSpaceDiscoveryResultMETA" returnedonly="true"> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + </type> + + <type category="struct" name="XrSpaceDiscoveryResultsMETA"> + <member values="XR_TYPE_SPACE_DISCOVERY_RESULTS_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>resultCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>resultCountOutput</name></member> + <member optional="true" len="resultCapacityInput"><type>XrSpaceDiscoveryResultMETA</type>* <name>results</name></member> + </type> + + <type category="struct" name="XrEventDataSpaceDiscoveryResultsAvailableMETA" returnedonly="true" parentstruct="XrEventDataBaseHeader"> + <member values="XR_TYPE_EVENT_DATA_SPACE_DISCOVERY_RESULTS_AVAILABLE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + </type> + + <type category="struct" name="XrEventDataSpaceDiscoveryCompleteMETA" returnedonly="true" parentstruct="XrEventDataBaseHeader"> + <member values="XR_TYPE_EVENT_DATA_SPACE_DISCOVERY_COMPLETE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + + <!-- XR_META_passthrough_color_lut types --> + <type category="struct" name="XrPassthroughColorLutDataMETA"> + <member><type>uint32_t</type> <name>bufferSize</name></member> + <member len="bufferSize">const <type>uint8_t</type>* <name>buffer</name></member> + </type> + + <type category="struct" name="XrPassthroughColorLutCreateInfoMETA"> + <member values="XR_TYPE_PASSTHROUGH_COLOR_LUT_CREATE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPassthroughColorLutChannelsMETA</type> <name>channels</name></member> + <member><type>uint32_t</type> <name>resolution</name></member> + <member><type>XrPassthroughColorLutDataMETA</type> <name>data</name></member> + </type> + + <type category="struct" name="XrPassthroughColorLutUpdateInfoMETA"> + <member values="XR_TYPE_PASSTHROUGH_COLOR_LUT_UPDATE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPassthroughColorLutDataMETA</type> <name>data</name></member> + </type> + + <type category="struct" name="XrPassthroughColorMapLutMETA" structextends="XrPassthroughStyleFB"> + <member values="XR_TYPE_PASSTHROUGH_COLOR_MAP_LUT_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPassthroughColorLutMETA</type> <name>colorLut</name></member> + <member><type>float</type> <name>weight</name></member> + </type> + + <type category="struct" name="XrPassthroughColorMapInterpolatedLutMETA" structextends="XrPassthroughStyleFB"> + <member values="XR_TYPE_PASSTHROUGH_COLOR_MAP_INTERPOLATED_LUT_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPassthroughColorLutMETA</type> <name>sourceColorLut</name></member> + <member><type>XrPassthroughColorLutMETA</type> <name>targetColorLut</name></member> + <member><type>float</type> <name>weight</name></member> + </type> + + <type category="struct" name="XrSystemPassthroughColorLutPropertiesMETA" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_PASSTHROUGH_COLOR_LUT_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>maxColorLutResolution</name></member> + </type> + + <!-- XR_HTC_foveation structs --> + <type category="struct" name="XrFoveationApplyInfoHTC"> + <member values="XR_TYPE_FOVEATION_APPLY_INFO_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrFoveationModeHTC</type> <name>mode</name></member> + <member><type>uint32_t</type> <name>subImageCount</name></member> + <member len="subImageCount"><type>XrSwapchainSubImage</type>* <name>subImages</name></member> + </type> + <type category="struct" name="XrFoveationConfigurationHTC"> + <member><type>XrFoveationLevelHTC</type> <name>level</name></member> + <member><type>float</type> <name>clearFovDegree</name></member> + <member><type>XrVector2f</type> <name>focalCenterOffset</name></member> + </type> + <type category="struct" name="XrFoveationDynamicModeInfoHTC" structextends="XrFoveationApplyInfoHTC"> + <member values="XR_TYPE_FOVEATION_DYNAMIC_MODE_INFO_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrFoveationDynamicFlagsHTC</type> <name>dynamicFlags</name></member> + </type> + <type category="struct" name="XrFoveationCustomModeInfoHTC" structextends="XrFoveationApplyInfoHTC"> + <member values="XR_TYPE_FOVEATION_CUSTOM_MODE_INFO_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>configCount</name></member> + <member len="configCount">const <type>XrFoveationConfigurationHTC</type>* <name>configs</name></member> + </type> + + <!-- XR_EXT_active_action_set_priority --> + <type category="struct" name="XrActiveActionSetPrioritiesEXT" structextends="XrActionsSyncInfo"> + <member values="XR_TYPE_ACTIVE_ACTION_SET_PRIORITIES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>actionSetPriorityCount</name></member> + <member len="actionSetPriorityCount">const <type>XrActiveActionSetPriorityEXT</type>* <name>actionSetPriorities</name></member> + </type> + + <type category="struct" name="XrActiveActionSetPriorityEXT"> + <member><type>XrActionSet</type> <name>actionSet</name></member> + <member><type>uint32_t</type> <name>priorityOverride</name></member> + </type> + + <!-- XR_FB_composition_layer_depth_test --> + <type category="struct" name="XrCompositionLayerDepthTestFB" structextends="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_DEPTH_TEST_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>depthMask</name></member> + <member><type>XrCompareOpFB</type> <name>compareOp</name></member> + </type> + <!-- XR_ML_compat structs --> + <type category="struct" name="XrCoordinateSpaceCreateInfoML"> + <member values="XR_TYPE_COORDINATE_SPACE_CREATE_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>MLCoordinateFrameUID</type> <name>cfuid</name></member> + <member><type>XrPosef</type> <name>poseInCoordinateSpace</name></member> + </type> + + + <!-- XR_ML_frame_end_info structs --> + <type category="struct" name="XrFrameEndInfoML" structextends="XrFrameEndInfo"> + <member values="XR_TYPE_FRAME_END_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>focusDistance</name></member> + <member optional="true"><type>XrFrameEndInfoFlagsML</type> <name>flags</name></member> + </type> + + <!-- XR_FB_haptic_amplitude_envelope struct --> + <type category="struct" name="XrHapticAmplitudeEnvelopeVibrationFB" parentstruct="XrHapticBaseHeader"> + <member values="XR_TYPE_HAPTIC_AMPLITUDE_ENVELOPE_VIBRATION_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrDuration</type> <name>duration</name></member> + <member><type>uint32_t</type> <name>amplitudeCount</name></member> + <member len="amplitudeCount">const <type>float</type>* <name>amplitudes</name></member> + </type> + + <!-- XR_FB_haptic_pcm structs --> + <type category="struct" name="XrHapticPcmVibrationFB" parentstruct="XrHapticBaseHeader"> + <member values="XR_TYPE_HAPTIC_PCM_VIBRATION_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>bufferSize</name></member> + <member len="bufferSize">const <type>float</type>* <name>buffer</name></member> + <member><type>float</type> <name>sampleRate</name></member> + <member><type>XrBool32</type> <name>append</name></member> + <member><type>uint32_t</type>* <name>samplesConsumed</name></member> + </type> + <type category="struct" name="XrDevicePcmSampleRateStateFB"> + <member values="XR_TYPE_DEVICE_PCM_SAMPLE_RATE_STATE_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>float</type> <name>sampleRate</name></member> + </type> + + <type category="struct" name="XrDevicePcmSampleRateGetInfoFB" alias="XrDevicePcmSampleRateStateFB"/> + + <!-- XR_FB_spatial_entity_user --> + <type category="struct" name="XrSpaceUserCreateInfoFB"> + <member values="XR_TYPE_SPACE_USER_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpaceUserIdFB</type> <name>userId</name></member> + </type> + + <!-- XR_MNDX_force_feedback_curl --> + <type category="struct" name="XrSystemForceFeedbackCurlPropertiesMNDX" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_FORCE_FEEDBACK_CURL_PROPERTIES_MNDX"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsForceFeedbackCurl</name></member> + </type> + + <type category="struct" name="XrForceFeedbackCurlApplyLocationsMNDX"> + <member values="XR_TYPE_FORCE_FEEDBACK_CURL_APPLY_LOCATIONS_MNDX"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>locationCount</name></member> + <member len="locationCount"><type>XrForceFeedbackCurlApplyLocationMNDX</type>* <name>locations</name></member> + </type> + + <type category="struct" name="XrForceFeedbackCurlApplyLocationMNDX"> + <member><type>XrForceFeedbackCurlLocationMNDX</type> <name>location</name></member> + <member><type>float</type> <name>value</name></member> + </type> + + <!-- XR_ANDROID_face_tracking --> + <type category="struct" name="XrFaceTrackerCreateInfoANDROID"> + <member values="XR_TYPE_FACE_TRACKER_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrFaceStateGetInfoANDROID"> + <member values="XR_TYPE_FACE_STATE_GET_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrFaceStateANDROID"> + <member values="XR_TYPE_FACE_STATE_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>parametersCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>parametersCountOutput</name></member> + <member optional="true" len="parametersCapacityInput"><type>float</type>* <name>parameters</name></member> + <member><type>XrFaceTrackingStateANDROID</type> <name>faceTrackingState</name></member> + <member><type>XrTime</type> <name>sampleTime</name></member> + <member><type>XrBool32</type> <name>isValid</name></member> + <member optional="true"><type>uint32_t</type> <name>regionConfidencesCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>regionConfidencesCountOutput</name></member> + <member optional="true" len="regionConfidencesCapacityInput"><type>float</type>* <name>regionConfidences</name></member> + </type> + <type category="struct" name="XrSystemFaceTrackingPropertiesANDROID" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsFaceTracking</name></member> + </type> + + <!-- XR_ANDROID_passthrough_camera_state --> + <type category="struct" name="XrSystemPassthroughCameraStatePropertiesANDROID" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_PASSTHROUGH_CAMERA_STATE_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsPassthroughCameraState</name></member> + </type> + <type category="struct" name="XrPassthroughCameraStateGetInfoANDROID"> + <member values="XR_TYPE_PASSTHROUGH_CAMERA_STATE_GET_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <!-- XR_ANDROID_trackables_object --> + <type category="struct" name="XrTrackableObjectANDROID"> + <member values="XR_TYPE_TRACKABLE_OBJECT_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrTrackingStateANDROID</type> <name>trackingState</name></member> + <member><type>XrPosef</type> <name>centerPose</name></member> + <member><type>XrExtent3DfEXT</type> <name>extents</name></member> + <member><type>XrObjectLabelANDROID</type> <name>objectLabel</name></member> + <member><type>XrTime</type> <name>lastUpdatedTime</name></member> + </type> + <type category="struct" name="XrTrackableObjectConfigurationANDROID" structextends="XrTrackableTrackerCreateInfoANDROID"> + <member values="XR_TYPE_TRACKABLE_OBJECT_CONFIGURATION_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>labelCount</name></member> + <member len="labelCount">const <type>XrObjectLabelANDROID</type>* <name>activeLabels</name></member> + </type> + + <!-- XR_ANDROID_raycast --> + <type category="struct" name="XrRaycastInfoANDROID"> + <member values="XR_TYPE_RAYCAST_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>maxResults</name></member> + <member><type>uint32_t</type> <name>trackerCount</name></member> + <member len="trackerCount">const <type>XrTrackableTrackerANDROID</type>* <name>trackers</name></member> + <member><type>XrVector3f</type> <name>origin</name></member> + <member><type>XrVector3f</type> <name>trajectory</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrRaycastHitResultANDROID" returnedonly="true"> + <member noautovalidity="true"><type>XrTrackableTypeANDROID</type> <name>type</name></member> + <member><type>XrTrackableANDROID</type> <name>trackable</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrRaycastHitResultsANDROID"> + <member values="XR_TYPE_RAYCAST_HIT_RESULTS_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>resultsCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>resultsCountOutput</name></member> + <member optional="true" len="resultsCapacityInput"><type>XrRaycastHitResultANDROID</type>* <name>results</name></member> + </type> + + <!-- XR_ANDROID_trackables_marker --> + <type category="struct" name="XrSystemMarkerTrackingPropertiesANDROID" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsMarkerTracking</name></member> + <member><type>XrBool32</type> <name>supportsMarkerSizeEstimation</name></member> + <member><type>uint16_t</type> <name>maxMarkerCount</name></member> + </type> + <type category="struct" name="XrTrackableMarkerConfigurationANDROID" structextends="XrTrackableTrackerCreateInfoANDROID"> + <member values="XR_TYPE_TRACKABLE_MARKER_CONFIGURATION_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrTrackableMarkerTrackingModeANDROID</type> <name>trackingMode</name></member> + <member><type>uint32_t</type> <name>databaseCount</name></member> + <member len="databaseCount">const <type>XrTrackableMarkerDatabaseANDROID</type>* <name>databases</name></member> + </type> + <type category="struct" name="XrTrackableMarkerDatabaseANDROID"> + <member><type>XrTrackableMarkerDictionaryANDROID</type> <name>dictionary</name></member> + <member optional="true"><type>uint32_t</type> <name>entryCount</name></member> + <member len="entryCount">const <type>XrTrackableMarkerDatabaseEntryANDROID</type>* <name>entries</name></member> + </type> + <type category="struct" name="XrTrackableMarkerDatabaseEntryANDROID"> + <member><type>int32_t</type> <name>id</name></member> + <member><type>float</type> <name>edgeSize</name></member> + </type> + <type category="struct" name="XrTrackableMarkerANDROID"> + <member values="XR_TYPE_TRACKABLE_MARKER_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrTrackingStateANDROID</type> <name>trackingState</name></member> + <member><type>XrTime</type> <name>lastUpdatedTime</name></member> + <member><type>XrTrackableMarkerDictionaryANDROID</type> <name>dictionary</name></member> + <member><type>int32_t</type> <name>markerId</name></member> + <member><type>XrPosef</type> <name>centerPose</name></member> + <member><type>XrExtent2Df</type> <name>extents</name></member> + </type> + + <!-- XR_ANDROID_anchor_sharing_export --> + <type category="struct" name="XrSystemAnchorSharingExportPropertiesANDROID" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_ANCHOR_SHARING_EXPORT_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsAnchorSharingExport</name></member> + </type> + <type category="struct" name="XrAnchorSharingInfoANDROID"> + <member values="XR_TYPE_ANCHOR_SHARING_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>anchor</name></member> + </type> + <type category="struct" name="XrAnchorSharingTokenANDROID" returnedonly="true"> + <member values="XR_TYPE_ANCHOR_SHARING_TOKEN_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member>struct <type>AIBinder</type>* <name>token</name></member> + </type> + + <!-- XR_ANDROID_device_anchor_persistence --> + <type category="struct" name="XrDeviceAnchorPersistenceCreateInfoANDROID"> + <member values="XR_TYPE_DEVICE_ANCHOR_PERSISTENCE_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrPersistedAnchorSpaceCreateInfoANDROID"> + <member values="XR_TYPE_PERSISTED_ANCHOR_SPACE_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrUuidEXT</type> <name>anchorId</name></member> + </type> + <type category="struct" name="XrPersistedAnchorSpaceInfoANDROID"> + <member values="XR_TYPE_PERSISTED_ANCHOR_SPACE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>anchor</name></member> + </type> + <type category="struct" name="XrSystemDeviceAnchorPersistencePropertiesANDROID" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_DEVICE_ANCHOR_PERSISTENCE_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsAnchorPersistence</name></member> + </type> + + <!-- XR_ANDROID_performance_metrics --> + <type category="struct" name="XrPerformanceMetricsStateANDROID"> + <member values="XR_TYPE_PERFORMANCE_METRICS_STATE_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>enabled</name></member> + </type> + <type category="struct" name="XrPerformanceMetricsCounterANDROID" returnedonly="true"> + <member values="XR_TYPE_PERFORMANCE_METRICS_COUNTER_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrPerformanceMetricsCounterFlagsANDROID</type> <name>counterFlags</name></member> + <member><type>XrPerformanceMetricsCounterUnitANDROID</type> <name>counterUnit</name></member> + <member><type>uint32_t</type> <name>uintValue</name></member> + <member><type>float</type> <name>floatValue</name></member> + </type> + + <!-- XR_ANDROID_trackables_qr_code --> + <type category="struct" name="XrSystemQrCodeTrackingPropertiesANDROID" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_QR_CODE_TRACKING_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsQrCodeTracking</name></member> + <member><type>XrBool32</type> <name>supportsQrCodeSizeEstimation</name></member> + <member><type>uint16_t</type> <name>maxQrCodeCount</name></member> + </type> + <type category="struct" name="XrTrackableQrCodeConfigurationANDROID" structextends="XrTrackableTrackerCreateInfoANDROID"> + <member values="XR_TYPE_TRACKABLE_QR_CODE_CONFIGURATION_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrQrCodeTrackingModeANDROID</type> <name>trackingMode</name></member> + <member><type>float</type> <name>qrCodeEdgeSize</name></member> + </type> + <type category="struct" name="XrTrackableQrCodeANDROID"> + <member values="XR_TYPE_TRACKABLE_QR_CODE_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrTrackingStateANDROID</type> <name>trackingState</name></member> + <member><type>XrTime</type> <name>lastUpdatedTime</name></member> + <member><type>XrPosef</type> <name>centerPose</name></member> + <member><type>XrExtent2Df</type> <name>extents</name></member> + <member optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>bufferCountOutput</name></member> + <member len="bufferCapacityInput" optional="true"><type>char</type>* <name>buffer</name></member> + </type> + + <!-- XR_ANDROID_composition_layer_passthrough_mesh --> + <type category="struct" name="XrSystemPassthroughLayerPropertiesANDROID" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_PASSTHROUGH_LAYER_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsPassthroughLayer</name></member> + <member><type>uint32_t</type> <name>maxMeshIndexCount</name></member> + <member><type>uint32_t</type> <name>maxMeshVertexCount</name></member> + </type> + <type category="struct" name="XrPassthroughLayerCreateInfoANDROID"> + <member values="XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>vertexCapacity</name></member> + <member><type>uint32_t</type> <name>indexCapacity</name></member> + </type> + <type category="struct" name="XrPassthroughLayerMeshANDROID" structextends="XrPassthroughLayerCreateInfoANDROID"> + <member values="XR_TYPE_PASSTHROUGH_LAYER_MESH_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrWindingOrderANDROID</type> <name>windingOrder</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCount</name></member> + <member len="vertexCount">const <type>XrVector3f</type>* <name>vertices</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCount</name></member> + <member len="indexCount">const <type>uint16_t</type>* <name>indices</name></member> + </type> + <type category="struct" name="XrCompositionLayerPassthroughANDROID" parentstruct="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrCompositionLayerFlags</type> <name>layerFlags</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrVector3f</type> <name>scale</name></member> + <member><type>float</type> <name>opacity</name></member> + <member><type>XrPassthroughLayerANDROID</type> <name>layer</name></member> + </type> + + <!-- XR_ANDROID_scene_meshing --> + <type category="struct" name="XrSystemSceneMeshingPropertiesANDROID" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_SCENE_MESHING_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSceneMeshing</name></member> + </type> + <type category="struct" name="XrSceneMeshingTrackerCreateInfoANDROID"> + <member values="XR_TYPE_SCENE_MESHING_TRACKER_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSceneMeshSemanticLabelSetANDROID</type> <name>semanticLabelSet</name></member> + <member><type>XrBool32</type> <name>enableNormals</name></member> + </type> + <type category="struct" name="XrSceneMeshSnapshotCreateInfoANDROID"> + <member values="XR_TYPE_SCENE_MESH_SNAPSHOT_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrBoxf</type> <name>boundingBox</name></member> + </type> + <type category="struct" name="XrSceneMeshSnapshotCreationResultANDROID"> + <member values="XR_TYPE_SCENE_MESH_SNAPSHOT_CREATION_RESULT_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSceneMeshSnapshotANDROID</type> <name>snapshot</name></member> + <member><type>XrSceneMeshTrackingStateANDROID</type> <name>trackingState</name></member> + </type> + <type category="struct" name="XrSceneSubmeshStateANDROID"> + <member values="XR_TYPE_SCENE_SUBMESH_STATE_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrUuid</type> <name>submeshId</name></member> + <member><type>XrTime</type> <name>lastUpdatedTime</name></member> + <member><type>XrPosef</type> <name>submeshPoseInBaseSpace</name></member> + <member><type>XrExtent3Df</type> <name>bounds</name></member> + </type> + <type category="struct" name="XrSceneSubmeshDataANDROID"> + <member values="XR_TYPE_SCENE_SUBMESH_DATA_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrUuid</type> <name>submeshId</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCountOutput</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector3f</type>* <name>vertexPositions</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector3f</type>* <name>vertexNormals</name></member> + <member optional="true" len="vertexCapacityInput"><type>uint8_t</type>* <name>vertexSemantics</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCountOutput</name></member> + <member optional="true" len="indexCapacityInput"><type>uint32_t</type>* <name>indices</name></member> + </type> + + <!-- XR_ANDROID_eye_tracking --> + <type category="struct" name="XrSystemEyeTrackingPropertiesANDROID" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_EYE_TRACKING_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsEyeTracking</name></member> + </type> + <type category="struct" name="XrEyeANDROID"> + <member><type>XrEyeStateANDROID</type> <name>eyeState</name></member> + <member><type>XrPosef</type> <name>eyePose</name></member> + </type> + <type category="struct" name="XrEyesANDROID"> + <member values="XR_TYPE_EYES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrEyeANDROID</type> <name>eyes</name>[<enum>XR_EYE_MAX_ANDROID</enum>]</member> + <member><type>XrEyeTrackingModeANDROID</type> <name>mode</name></member> + </type> + <type category="struct" name="XrEyesGetInfoANDROID"> + <member values="XR_TYPE_EYES_GET_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + </type> + <type category="struct" name="XrEyeTrackerCreateInfoANDROID"> + <member values="XR_TYPE_EYE_TRACKER_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <!-- XR_ANDROID_recommended_resolution --> + <type category="struct" name="XrEventDataRecommendedResolutionChangedANDROID" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_RECOMMENDED_RESOLUTION_CHANGED_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <!-- XR_ANDROID_light_estimation --> + <type category="struct" name="XrSystemLightEstimationPropertiesANDROID" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_LIGHT_ESTIMATION_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsLightEstimation</name></member> + </type> + <type category="struct" name="XrLightEstimatorCreateInfoANDROID"> + <member values="XR_TYPE_LIGHT_ESTIMATOR_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrLightEstimateGetInfoANDROID"> + <member values="XR_TYPE_LIGHT_ESTIMATE_GET_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrLightEstimateANDROID"> + <member values="XR_TYPE_LIGHT_ESTIMATE_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrLightEstimateStateANDROID</type> <name>state</name></member> + <member><type>XrTime</type> <name>lastUpdatedTime</name></member> + </type> + <type category="struct" name="XrDirectionalLightANDROID" structextends="XrLightEstimateANDROID"> + <member values="XR_TYPE_DIRECTIONAL_LIGHT_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrLightEstimateStateANDROID</type> <name>state</name></member> + <member><type>XrVector3f</type> <name>intensity</name></member> + <member><type>XrVector3f</type> <name>direction</name></member> + </type> + <type category="struct" name="XrAmbientLightANDROID" structextends="XrLightEstimateANDROID"> + <member values="XR_TYPE_AMBIENT_LIGHT_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrLightEstimateStateANDROID</type> <name>state</name></member> + <member><type>XrVector3f</type> <name>intensity</name></member> + <member><type>XrVector3f</type> <name>colorCorrection</name></member> + </type> + <type category="struct" name="XrSphericalHarmonicsANDROID" structextends="XrLightEstimateANDROID"> + <member values="XR_TYPE_SPHERICAL_HARMONICS_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrLightEstimateStateANDROID</type> <name>state</name></member> + <member><type>XrSphericalHarmonicsKindANDROID</type> <name>kind</name></member> + <member><type>float</type> <name>coefficients</name>[9][3]</member> + </type> + + <!-- XR_EXT_plane_detection --> + <type category="struct" name="XrSystemPlaneDetectionPropertiesEXT" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_PLANE_DETECTION_PROPERTIES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrPlaneDetectionCapabilityFlagsEXT</type> <name>supportedFeatures</name></member> + </type> + + <type category="struct" name="XrPlaneDetectorCreateInfoEXT"> + <member values="XR_TYPE_PLANE_DETECTOR_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrPlaneDetectorFlagsEXT</type> <name>flags</name></member> + </type> + + <type category="struct" name="XrPlaneDetectorBeginInfoEXT"> + <member values="XR_TYPE_PLANE_DETECTOR_BEGIN_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member optional="true"><type>uint32_t</type> <name>orientationCount</name></member> + <member optional="true" len="orientationCount">const <type>XrPlaneDetectorOrientationEXT</type>* <name>orientations</name></member> + <member optional="true"><type>uint32_t</type> <name>semanticTypeCount</name></member> + <member optional="true" len="semanticTypeCount">const <type>XrPlaneDetectorSemanticTypeEXT</type>* <name>semanticTypes</name></member> + <member><type>uint32_t</type> <name>maxPlanes</name></member> + <member><type>float</type> <name>minArea</name></member> + <member><type>XrPosef</type> <name>boundingBoxPose</name></member> + <member><type>XrExtent3DfEXT</type> <name>boundingBoxExtent</name></member> + </type> + + <type category="struct" name="XrPlaneDetectorGetInfoEXT"> + <member values="XR_TYPE_PLANE_DETECTOR_GET_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <type category="struct" name="XrPlaneDetectorLocationsEXT"> + <member values="XR_TYPE_PLANE_DETECTOR_LOCATIONS_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>planeLocationCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>planeLocationCountOutput</name></member> + <member optional="true" len="planeLocationCapacityInput"><type>XrPlaneDetectorLocationEXT</type>* <name>planeLocations</name></member> + </type> + + <type category="struct" name="XrPlaneDetectorLocationEXT"> + <member values="XR_TYPE_PLANE_DETECTOR_LOCATION_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint64_t</type> <name>planeId</name></member> + <member optional="true"><type>XrSpaceLocationFlags</type> <name>locationFlags</name></member> + <member optional="true"><type>XrPosef</type> <name>pose</name></member> + <member optional="true"><type>XrExtent2Df</type> <name>extents</name></member> + <member optional="true"><type>XrPlaneDetectorOrientationEXT</type> <name>orientation</name></member> + <member optional="true"><type>XrPlaneDetectorSemanticTypeEXT</type> <name>semanticType</name></member> + <member optional="true"><type>uint32_t</type> <name>polygonBufferCount</name></member> + </type> + + <type category="struct" name="XrPlaneDetectorPolygonBufferEXT"> + <member values="XR_TYPE_PLANE_DETECTOR_POLYGON_BUFFER_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCountOutput</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector2f</type>* <name>vertices</name></member> + </type> + + <!-- XR_META_virtual_keyboard --> + <type category="struct" name="XrSystemVirtualKeyboardPropertiesMETA" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_VIRTUAL_KEYBOARD_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsVirtualKeyboard</name></member> + </type> + + <type category="struct" name="XrVirtualKeyboardCreateInfoMETA"> + <member values="XR_TYPE_VIRTUAL_KEYBOARD_CREATE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrVirtualKeyboardSpaceCreateInfoMETA"> + <member values="XR_TYPE_VIRTUAL_KEYBOARD_SPACE_CREATE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrVirtualKeyboardLocationTypeMETA</type> <name>locationType</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrPosef</type> <name>poseInSpace</name></member> + </type> + + <type category="struct" name="XrVirtualKeyboardLocationInfoMETA"> + <member values="XR_TYPE_VIRTUAL_KEYBOARD_LOCATION_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrVirtualKeyboardLocationTypeMETA</type> <name>locationType</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrPosef</type> <name>poseInSpace</name></member> + <member><type>float</type> <name>scale</name></member> + </type> + + <type category="struct" name="XrVirtualKeyboardModelVisibilitySetInfoMETA"> + <member values="XR_TYPE_VIRTUAL_KEYBOARD_MODEL_VISIBILITY_SET_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>visible</name></member> + </type> + + <type category="struct" name="XrVirtualKeyboardAnimationStateMETA"> + <member values="XR_TYPE_VIRTUAL_KEYBOARD_ANIMATION_STATE_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>int32_t</type> <name>animationIndex</name></member> + <member><type>float</type> <name>fraction</name></member> + </type> + + <type category="struct" name="XrVirtualKeyboardModelAnimationStatesMETA"> + <member values="XR_TYPE_VIRTUAL_KEYBOARD_MODEL_ANIMATION_STATES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>stateCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>stateCountOutput</name></member> + <member len="stateCapacityInput" optional="true"><type>XrVirtualKeyboardAnimationStateMETA</type>* <name>states</name></member> + </type> + + <type category="struct" name="XrVirtualKeyboardTextureDataMETA"> + <member values="XR_TYPE_VIRTUAL_KEYBOARD_TEXTURE_DATA_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>textureWidth</name></member> + <member><type>uint32_t</type> <name>textureHeight</name></member> + <member optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>bufferCountOutput</name></member> + <member len="bufferCapacityInput" optional="true"><type>uint8_t</type>* <name>buffer</name></member> + </type> + + <type category="struct" name="XrVirtualKeyboardInputInfoMETA"> + <member values="XR_TYPE_VIRTUAL_KEYBOARD_INPUT_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrVirtualKeyboardInputSourceMETA</type> <name>inputSource</name></member> + <member optional="true"><type>XrSpace</type> <name>inputSpace</name></member> + <member optional="true"><type>XrPosef</type> <name>inputPoseInSpace</name></member> + <member optional="true"><type>XrVirtualKeyboardInputStateFlagsMETA</type> <name>inputState</name></member> + </type> + + <type category="struct" name="XrVirtualKeyboardTextContextChangeInfoMETA"> + <member values="XR_TYPE_VIRTUAL_KEYBOARD_TEXT_CONTEXT_CHANGE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member len="null-terminated">const <type>char</type>* <name>textContext</name></member> + </type> + + <type category="struct" name="XrEventDataVirtualKeyboardCommitTextMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_COMMIT_TEXT_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></member> + <member><type>char</type> <name>text</name>[<enum>XR_MAX_VIRTUAL_KEYBOARD_COMMIT_TEXT_SIZE_META</enum>]</member> + </type> + + <type category="struct" name="XrEventDataVirtualKeyboardBackspaceMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_BACKSPACE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></member> + </type> + + <type category="struct" name="XrEventDataVirtualKeyboardEnterMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_ENTER_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></member> + </type> + + <type category="struct" name="XrEventDataVirtualKeyboardShownMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_SHOWN_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></member> + </type> + + <type category="struct" name="XrEventDataVirtualKeyboardHiddenMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_HIDDEN_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></member> + </type> + + <!-- XR_ML_user_calibration --> + <type category="struct" name="XrUserCalibrationEnableEventsInfoML"> + <member values="XR_TYPE_USER_CALIBRATION_ENABLE_EVENTS_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>enabled</name></member> + </type> + + <type category="struct" name="XrEventDataHeadsetFitChangedML" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_HEADSET_FIT_CHANGED_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrHeadsetFitStatusML</type> <name>status</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <type category="struct" name="XrEventDataEyeCalibrationChangedML" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_EYE_CALIBRATION_CHANGED_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrEyeCalibrationStatusML</type> <name>status</name></member> + </type> + + <!-- XR_ML_localization_map --> + <type category="struct" name="XrLocalizationMapML"> + <member values="XR_TYPE_LOCALIZATION_MAP_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>char</type> <name>name</name>[<enum>XR_MAX_LOCALIZATION_MAP_NAME_LENGTH_ML</enum>]</member> + <member optional="true"><type>XrUuidEXT</type> <name>mapUuid</name></member> + <member optional="true"><type>XrLocalizationMapTypeML</type> <name>mapType</name></member> + </type> + + <type category="struct" name="XrLocalizationEnableEventsInfoML"> + <member values="XR_TYPE_LOCALIZATION_ENABLE_EVENTS_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>enabled</name></member> + </type> + + <type category="struct" name="XrEventDataLocalizationChangedML" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_LOCALIZATION_CHANGED_ML"> <type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSession</type> <name>session</name></member> + <member><type>XrLocalizationMapStateML</type> <name>state</name></member> + <member><type>XrLocalizationMapML</type> <name>map</name></member> + <member><type>XrLocalizationMapConfidenceML</type> <name>confidence</name></member> + <member><type>XrLocalizationMapErrorFlagsML</type> <name>errorFlags</name></member> + </type> + + <type category="struct" name="XrLocalizationMapQueryInfoBaseHeaderML"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrMapLocalizationRequestInfoML"> + <member values="XR_TYPE_MAP_LOCALIZATION_REQUEST_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrUuidEXT</type> <name>mapUuid</name></member> + </type> + + <type category="struct" name="XrLocalizationMapImportInfoML"> + <member values="XR_TYPE_LOCALIZATION_MAP_IMPORT_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>size</name></member> + <member len="size"><type>char</type>* <name>data</name></member> + </type> + + + <!-- XR_ML_marker_understanding --> + <type category="struct" name="XrSystemMarkerUnderstandingPropertiesML" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_MARKER_UNDERSTANDING_PROPERTIES_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsMarkerUnderstanding</name></member> + </type> + + <type category="struct" name="XrMarkerDetectorCreateInfoML"> + <member values="XR_TYPE_MARKER_DETECTOR_CREATE_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrMarkerDetectorProfileML</type> <name>profile</name></member> + <member><type>XrMarkerTypeML</type> <name>markerType</name></member> + </type> + + <type category="struct" name="XrMarkerDetectorArucoInfoML" structextends="XrMarkerDetectorCreateInfoML"> + <member values="XR_TYPE_MARKER_DETECTOR_ARUCO_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrMarkerArucoDictML</type> <name>arucoDict</name></member> + </type> + + <type category="struct" name="XrMarkerDetectorSizeInfoML" structextends="XrMarkerDetectorCreateInfoML"> + <member values="XR_TYPE_MARKER_DETECTOR_SIZE_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>markerLength</name></member> + </type> + + <type category="struct" name="XrMarkerDetectorAprilTagInfoML" structextends="XrMarkerDetectorCreateInfoML"> + <member values="XR_TYPE_MARKER_DETECTOR_APRIL_TAG_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrMarkerAprilTagDictML</type> <name>aprilTagDict</name></member> + </type> + + <type category="struct" name="XrMarkerDetectorCustomProfileInfoML" structextends="XrMarkerDetectorCreateInfoML"> + <member values="XR_TYPE_MARKER_DETECTOR_CUSTOM_PROFILE_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrMarkerDetectorFpsML</type> <name>fpsHint</name></member> + <member><type>XrMarkerDetectorResolutionML</type> <name>resolutionHint</name></member> + <member><type>XrMarkerDetectorCameraML</type> <name>cameraHint</name></member> + <member><type>XrMarkerDetectorCornerRefineMethodML</type> <name>cornerRefineMethod</name></member> + <member><type>XrBool32</type> <name>useEdgeRefinement</name></member> + <member><type>XrMarkerDetectorFullAnalysisIntervalML</type> <name>fullAnalysisIntervalHint</name></member> + </type> + + <type category="struct" name="XrMarkerDetectorSnapshotInfoML"> + <member values="XR_TYPE_MARKER_DETECTOR_SNAPSHOT_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrMarkerDetectorStateML" returnedonly="true"> + <member values="XR_TYPE_MARKER_DETECTOR_STATE_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrMarkerDetectorStatusML</type> <name>state</name></member> + </type> + + <type category="struct" name="XrMarkerSpaceCreateInfoML"> + <member values="XR_TYPE_MARKER_SPACE_CREATE_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrMarkerDetectorML</type> <name>markerDetector</name></member> + <member><type>XrMarkerML</type> <name>marker</name></member> + <member><type>XrPosef</type> <name>poseInMarkerSpace</name></member> + </type> + + <type category="struct" name="XrColor3f"> + <member><type>float</type> <name>r</name></member> + <member><type>float</type> <name>g</name></member> + <member><type>float</type> <name>b</name></member> + </type> + + <type category="struct" name="XrExtent3Df"> + <member><type>float</type> <name>width</name></member> + <member><type>float</type> <name>height</name></member> + <member><type>float</type> <name>depth</name></member> + </type> + + <type category="struct" name="XrSpheref"> + <member><type>XrPosef</type> <name>center</name></member> + <member><type>float</type> <name>radius</name></member> + </type> + + <type category="struct" name="XrBoxf"> + <member><type>XrPosef</type> <name>center</name></member> + <member><type>XrExtent3Df</type> <name>extents</name></member> + </type> + + <type category="struct" name="XrFrustumf"> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrFovf</type> <name>fov</name></member> + <member><type>float</type> <name>nearZ</name></member> + <member><type>float</type> <name>farZ</name></member> + </type> + + <type category="struct" name="XrUuid"> + <member><type>uint8_t</type> <name>data</name>[XR_UUID_SIZE]</member> + </type> + + <!-- XR_KHR_maintenance1 --> + <type category="struct" name="XrColor3fKHR" alias="XrColor3f"/> + + <type category="struct" name="XrExtent3DfKHR" alias="XrExtent3Df"/> + + <type category="struct" name="XrSpherefKHR" alias="XrSpheref"/> + + <type category="struct" name="XrBoxfKHR" alias="XrBoxf"/> + + <type category="struct" name="XrFrustumfKHR" alias="XrFrustumf"/> + + <!-- XR_ML_facial_expression --> + <type category="struct" name="XrSystemFacialExpressionPropertiesML" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_FACIAL_EXPRESSION_PROPERTIES_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsFacialExpression</name></member> + </type> + <type category="struct" name="XrFacialExpressionClientCreateInfoML"> + <member values="XR_TYPE_FACIAL_EXPRESSION_CLIENT_CREATE_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>requestedCount</name></member> + <member optional="true" len="requestedCount">const <type>XrFacialBlendShapeML</type>* <name>requestedFacialBlendShapes</name></member> + </type> + <type category="struct" name="XrFacialExpressionBlendShapePropertiesML"> + <member values="XR_TYPE_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrFacialBlendShapeML</type> <name>requestedFacialBlendShape</name></member> + <member noautovalidity="true"><type>float</type> <name>weight</name></member> + <member noautovalidity="true"><type>XrFacialExpressionBlendShapePropertiesFlagsML</type> <name>flags</name></member> + <member noautovalidity="true"><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrFacialExpressionBlendShapeGetInfoML"> + <member values="XR_TYPE_FACIAL_EXPRESSION_BLEND_SHAPE_GET_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <!-- XR_META_recommended_layer_resolution types --> + <type category="struct" name="XrRecommendedLayerResolutionMETA" returnedonly="true"> + <member values="XR_TYPE_RECOMMENDED_LAYER_RESOLUTION_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrExtent2Di</type> <name>recommendedImageDimensions</name></member> + <member><type>XrBool32</type> <name>isValid</name></member> + </type> + + <type category="struct" name="XrRecommendedLayerResolutionGetInfoMETA"> + <member values="XR_TYPE_RECOMMENDED_LAYER_RESOLUTION_GET_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member>const <type>XrCompositionLayerBaseHeader</type>* <name>layer</name></member> + <member><type>XrTime</type> <name>predictedDisplayTime</name></member> + </type> + + <!-- XR_EXT_user_presence --> + <type category="struct" name="XrSystemUserPresencePropertiesEXT" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_USER_PRESENCE_PROPERTIES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsUserPresence</name></member> + </type> + + <type category="struct" name="XrEventDataUserPresenceChangedEXT" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_USER_PRESENCE_CHANGED_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSession</type> <name>session</name></member> + <member><type>XrBool32</type> <name>isUserPresent</name></member> + </type> + + <!-- XR_EXT_future --> + <type category="struct" name="XrFutureCompletionBaseHeaderEXT"> + <member><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + </type> + + <type category="struct" name="XrFutureCompletionEXT" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_FUTURE_COMPLETION_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + </type> + + <type category="struct" name="XrFutureCancelInfoEXT"> + <member values="XR_TYPE_FUTURE_CANCEL_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrFutureEXT</type> <name>future</name></member> + </type> + + <type category="struct" name="XrFuturePollInfoEXT"> + <member values="XR_TYPE_FUTURE_POLL_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrFutureEXT</type> <name>future</name></member> + </type> + + <type category="struct" name="XrFuturePollResultEXT" returnedonly="true"> + <member values="XR_TYPE_FUTURE_POLL_RESULT_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrFutureStateEXT</type> <name>state</name></member> + </type> + + + + <!-- XR_META_environment_depth --> + <type category="struct" name="XrEnvironmentDepthProviderCreateInfoMETA"> + <member values="XR_TYPE_ENVIRONMENT_DEPTH_PROVIDER_CREATE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrEnvironmentDepthProviderCreateFlagsMETA</type> <name>createFlags</name></member> + </type> + <type category="struct" name="XrEnvironmentDepthSwapchainCreateInfoMETA"> + <member values="XR_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_CREATE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrEnvironmentDepthSwapchainCreateFlagsMETA</type> <name>createFlags</name></member> + </type> + <type category="struct" name="XrEnvironmentDepthSwapchainStateMETA"> + <member values="XR_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_STATE_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>width</name></member> + <member><type>uint32_t</type> <name>height</name></member> + </type> + <type category="struct" name="XrEnvironmentDepthImageAcquireInfoMETA"> + <member values="XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_ACQUIRE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrTime</type> <name>displayTime</name></member> + </type> + <type category="struct" name="XrEnvironmentDepthImageViewMETA"> + <member values="XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_VIEW_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrFovf</type> <name>fov</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrEnvironmentDepthImageMETA"> + <member values="XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>swapchainIndex</name></member> + <member><type>float</type> <name>nearZ</name></member> + <member><type>float</type> <name>farZ</name></member> + <member><type>XrEnvironmentDepthImageViewMETA</type> <name>views</name>[2]</member> + </type> + <type category="struct" name="XrEnvironmentDepthImageTimestampMETA" structextends="XrEnvironmentDepthImageMETA"> + <member values="XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_TIMESTAMP_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>captureTime</name></member> + </type> + <type category="struct" name="XrEnvironmentDepthHandRemovalSetInfoMETA"> + <member values="XR_TYPE_ENVIRONMENT_DEPTH_HAND_REMOVAL_SET_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>enabled</name></member> + </type> + <type category="struct" name="XrSystemEnvironmentDepthPropertiesMETA" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_ENVIRONMENT_DEPTH_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsEnvironmentDepth</name></member> + <member><type>XrBool32</type> <name>supportsHandRemoval</name></member> + </type> + + <!-- XR_KHR_locate_spaces --> + <type category="struct" name="XrSpacesLocateInfoKHR" alias="XrSpacesLocateInfo"/> + <type category="struct" name="XrSpacesLocateInfo"> + <member values="XR_TYPE_SPACES_LOCATE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>uint32_t</type> <name>spaceCount</name></member> + <member len="spaceCount">const <type>XrSpace</type>* <name>spaces</name></member> + </type> + + <type category="struct" name="XrSpaceLocationsKHR" alias="XrSpaceLocations"/> + <type category="struct" name="XrSpaceLocations"> + <member values="XR_TYPE_SPACE_LOCATIONS"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>locationCount</name></member> + <member len="locationCount"><type>XrSpaceLocationData</type>* <name>locations</name></member> + </type> + + <type category="struct" name="XrSpaceLocationDataKHR" alias="XrSpaceLocationData"/> + <type category="struct" name="XrSpaceLocationData" returnedonly="true"> + <member><type>XrSpaceLocationFlags</type> <name>locationFlags</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + + <type category="struct" name="XrSpaceVelocitiesKHR" alias="XrSpaceVelocities"/> + <type category="struct" name="XrSpaceVelocities" structextends="XrSpaceLocations"> + <member values="XR_TYPE_SPACE_VELOCITIES"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>velocityCount</name></member> + <member len="velocityCount"><type>XrSpaceVelocityData</type>* <name>velocities</name></member> + </type> + + <type category="struct" name="XrSpaceVelocityDataKHR" alias="XrSpaceVelocityData"/> + <type category="struct" name="XrSpaceVelocityData" returnedonly="true"> + <member><type>XrSpaceVelocityFlags</type> <name>velocityFlags</name></member> + <member><type>XrVector3f</type> <name>linearVelocity</name></member> + <member><type>XrVector3f</type> <name>angularVelocity</name></member> + </type> + + <!-- XR_EXT_spatial_entity --> + <type category="struct" name="XrSpatialCapabilityComponentTypesEXT"> + <member values="XR_TYPE_SPATIAL_CAPABILITY_COMPONENT_TYPES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>componentTypeCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>componentTypeCountOutput</name></member> + <member len="componentTypeCapacityInput" optional="true"><type>XrSpatialComponentTypeEXT</type>* <name>componentTypes</name></member> + </type> + + <type category="struct" name="XrSpatialCapabilityConfigurationBaseHeaderEXT"> + <member noautovalidity="true"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialCapabilityEXT</type> <name>capability</name></member> + <member><type>uint32_t</type> <name>enabledComponentCount</name></member> + <member len="enabledComponentCount">const <type>XrSpatialComponentTypeEXT</type>* <name>enabledComponents</name></member> + </type> + + <type category="struct" name="XrSpatialContextCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_CONTEXT_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>capabilityConfigCount</name></member> + <member len="capabilityConfigCount">const <type>XrSpatialCapabilityConfigurationBaseHeaderEXT</type>* const* <name>capabilityConfigs</name></member> + </type> + + <type category="struct" name="XrCreateSpatialContextCompletionEXT" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_CREATE_SPATIAL_CONTEXT_COMPLETION_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member optional="true"><type>XrSpatialContextEXT</type> <name>spatialContext</name></member> + </type> + + <type category="struct" name="XrSpatialDiscoverySnapshotCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_DISCOVERY_SNAPSHOT_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>componentTypeCount</name></member> + <member optional="true" len="componentTypeCount">const <type>XrSpatialComponentTypeEXT</type>* <name>componentTypes</name></member> + </type> + + <type category="struct" name="XrCreateSpatialDiscoverySnapshotCompletionInfoEXT"> + <member values="XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrFutureEXT</type> <name>future</name></member> + </type> + + <type category="struct" name="XrCreateSpatialDiscoverySnapshotCompletionEXT" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member optional="true"><type>XrSpatialSnapshotEXT</type> <name>snapshot</name></member> + </type> + + <type category="struct" name="XrSpatialComponentDataQueryConditionEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_CONDITION_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>componentTypeCount</name></member> + <member optional="true" len="componentTypeCount">const <type>XrSpatialComponentTypeEXT</type>* <name>componentTypes</name></member> + </type> + + <type category="struct" name="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_RESULT_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>entityIdCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>entityIdCountOutput</name></member> + <member len="entityIdCapacityInput" optional="true"><type>XrSpatialEntityIdEXT</type>* <name>entityIds</name></member> + <member optional="true"><type>uint32_t</type> <name>entityStateCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>entityStateCountOutput</name></member> + <member len="entityStateCapacityInput" optional="true"><type>XrSpatialEntityTrackingStateEXT</type>* <name>entityStates</name></member> + </type> + + <type category="struct" name="XrSpatialBufferEXT"> + <member><type>XrSpatialBufferIdEXT</type> <name>bufferId</name></member> + <member><type>XrSpatialBufferTypeEXT</type> <name>bufferType</name></member> + </type> + + <type category="struct" name="XrSpatialBufferGetInfoEXT"> + <member values="XR_TYPE_SPATIAL_BUFFER_GET_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialBufferIdEXT</type> <name>bufferId</name></member> + </type> + + <type category="struct" name="XrSpatialBounded2DDataEXT"> + <member><type>XrPosef</type> <name>center</name></member> + <member><type>XrExtent2Df</type> <name>extents</name></member> + </type> + + <type category="struct" name="XrSpatialComponentBounded2DListEXT" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_BOUNDED_2D_LIST_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>boundCount</name></member> + <member len="boundCount"><type>XrSpatialBounded2DDataEXT</type>* <name>bounds</name></member> + </type> + + <type category="struct" name="XrSpatialComponentBounded3DListEXT" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_BOUNDED_3D_LIST_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>boundCount</name></member> + <member len="boundCount"><type>XrBoxf</type>* <name>bounds</name></member> + </type> + + <type category="struct" name="XrSpatialComponentParentListEXT" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_PARENT_LIST_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>parentCount</name></member> + <member len="parentCount"><type>XrSpatialEntityIdEXT</type>* <name>parents</name></member> + </type> + + <type category="struct" name="XrSpatialMeshDataEXT"> + <member><type>XrPosef</type> <name>origin</name></member> + <member><type>XrSpatialBufferEXT</type> <name>vertexBuffer</name></member> + <member><type>XrSpatialBufferEXT</type> <name>indexBuffer</name></member> + </type> + + <type category="struct" name="XrSpatialComponentMesh3DListEXT" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_MESH_3D_LIST_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>meshCount</name></member> + <member len="meshCount"><type>XrSpatialMeshDataEXT</type>* <name>meshes</name></member> + </type> + + <type category="struct" name="XrSpatialEntityFromIdCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_ENTITY_FROM_ID_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialEntityIdEXT</type> <name>entityId</name></member> + </type> + + <type category="struct" name="XrSpatialUpdateSnapshotCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_UPDATE_SNAPSHOT_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>entityCount</name></member> + <member len="entityCount">const <type>XrSpatialEntityEXT</type>* <name>entities</name></member> + <member optional="true"><type>uint32_t</type> <name>componentTypeCount</name></member> + <member optional="true" len="componentTypeCount">const <type>XrSpatialComponentTypeEXT</type>* <name>componentTypes</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <type category="struct" name="XrEventDataSpatialDiscoveryRecommendedEXT" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialContextEXT</type> <name>spatialContext</name></member> + </type> + + <type category="struct" name="XrSpatialFilterTrackingStateEXT" structextends="XrSpatialDiscoverySnapshotCreateInfoEXT,XrSpatialComponentDataQueryConditionEXT"> + <member values="XR_TYPE_SPATIAL_FILTER_TRACKING_STATE_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialEntityTrackingStateEXT</type> <name>trackingState</name></member> + </type> + + <!-- XR_EXT_spatial_anchor --> + <type category="struct" name="XrSpatialCapabilityConfigurationAnchorEXT" parentstruct="XrSpatialCapabilityConfigurationBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ANCHOR_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialCapabilityEXT</type> <name>capability</name></member> + <member><type>uint32_t</type> <name>enabledComponentCount</name></member> + <member len="enabledComponentCount">const <type>XrSpatialComponentTypeEXT</type>* <name>enabledComponents</name></member> + </type> + + <type category="struct" name="XrSpatialComponentAnchorListEXT" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_ANCHOR_LIST_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>locationCount</name></member> + <member len="locationCount"><type>XrPosef</type>* <name>locations</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + + <!-- XR_EXT_spatial_persistence --> + <type category="struct" name="XrSpatialPersistenceContextCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_PERSISTENCE_CONTEXT_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialPersistenceScopeEXT</type> <name>scope</name></member> + </type> + + <type category="struct" name="XrCreateSpatialPersistenceContextCompletionEXT" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_CREATE_SPATIAL_PERSISTENCE_CONTEXT_COMPLETION_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>XrSpatialPersistenceContextResultEXT</type> <name>createResult</name></member> + <member><type>XrSpatialPersistenceContextEXT</type> <name>persistenceContext</name></member> + </type> + + <type category="struct" name="XrSpatialContextPersistenceConfigEXT" structextends="XrSpatialContextCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_CONTEXT_PERSISTENCE_CONFIG_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>persistenceContextCount</name></member> + <member len="persistenceContextCount">const <type>XrSpatialPersistenceContextEXT</type>* <name>persistenceContexts</name></member> + </type> + + <type category="struct" name="XrSpatialDiscoveryPersistenceUuidFilterEXT" structextends="XrSpatialDiscoverySnapshotCreateInfoEXT,XrSpatialComponentDataQueryConditionEXT"> + <member values="XR_TYPE_SPATIAL_DISCOVERY_PERSISTENCE_UUID_FILTER_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>persistedUuidCount</name></member> + <member len="persistedUuidCount">const <type>XrUuid</type>* <name>persistedUuids</name></member> + </type> + + <type category="struct" name="XrSpatialPersistenceDataEXT"> + <member><type>XrUuid</type> <name>persistUuid</name></member> + <member><type>XrSpatialPersistenceStateEXT</type> <name>persistState</name></member> + </type> + + <type category="struct" name="XrSpatialComponentPersistenceListEXT" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_PERSISTENCE_LIST_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>persistDataCount</name></member> + <member len="persistDataCount"><type>XrSpatialPersistenceDataEXT</type>* <name>persistData</name></member> + </type> + + <!-- XR_EXT_spatial_persistence_operations --> + <type category="struct" name="XrSpatialEntityPersistInfoEXT"> + <member values="XR_TYPE_SPATIAL_ENTITY_PERSIST_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialContextEXT</type> <name>spatialContext</name></member> + <member><type>XrSpatialEntityIdEXT</type> <name>spatialEntityId</name></member> + </type> + + <type category="struct" name="XrPersistSpatialEntityCompletionEXT" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_PERSIST_SPATIAL_ENTITY_COMPLETION_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>XrSpatialPersistenceContextResultEXT</type> <name>persistResult</name></member> + <member><type>XrUuid</type> <name>persistUuid</name></member> + </type> + + <type category="struct" name="XrSpatialEntityUnpersistInfoEXT"> + <member values="XR_TYPE_SPATIAL_ENTITY_UNPERSIST_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrUuid</type> <name>persistUuid</name></member> + </type> + + <type category="struct" name="XrUnpersistSpatialEntityCompletionEXT" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_UNPERSIST_SPATIAL_ENTITY_COMPLETION_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>XrSpatialPersistenceContextResultEXT</type> <name>unpersistResult</name></member> + </type> + + <!-- XR_EXT_spatial_plane_tracking --> + <type category="struct" name="XrSpatialCapabilityConfigurationPlaneTrackingEXT" parentstruct="XrSpatialCapabilityConfigurationBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_PLANE_TRACKING_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialCapabilityEXT</type> <name>capability</name></member> + <member><type>uint32_t</type> <name>enabledComponentCount</name></member> + <member len="enabledComponentCount">const <type>XrSpatialComponentTypeEXT</type>* <name>enabledComponents</name></member> + </type> + + <type category="struct" name="XrSpatialComponentPlaneAlignmentListEXT" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_PLANE_ALIGNMENT_LIST_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>planeAlignmentCount</name></member> + <member len="planeAlignmentCount"><type>XrSpatialPlaneAlignmentEXT</type>* <name>planeAlignments</name></member> + </type> + + <type category="struct" name="XrSpatialComponentMesh2DListEXT" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_MESH_2D_LIST_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>meshCount</name></member> + <member len="meshCount"><type>XrSpatialMeshDataEXT</type>* <name>meshes</name></member> + </type> + + <type category="struct" name="XrSpatialPolygon2DDataEXT"> + <member><type>XrPosef</type> <name>origin</name></member> + <member><type>XrSpatialBufferEXT</type> <name>vertexBuffer</name></member> + </type> + + <type category="struct" name="XrSpatialComponentPolygon2DListEXT" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_POLYGON_2D_LIST_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>polygonCount</name></member> + <member len="polygonCount"><type>XrSpatialPolygon2DDataEXT</type>* <name>polygons</name></member> + </type> + + <type category="struct" name="XrSpatialComponentPlaneSemanticLabelListEXT" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_PLANE_SEMANTIC_LABEL_LIST_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>semanticLabelCount</name></member> + <member len="semanticLabelCount"><type>XrSpatialPlaneSemanticLabelEXT</type>* <name>semanticLabels</name></member> + </type> + + <!-- XR_EXT_stationary_reference_space --> + <type category="struct" name="XrStationaryReferenceSpaceGenerationIdGetInfoEXT"> + <member values="XR_TYPE_STATIONARY_REFERENCE_SPACE_GENERATION_ID_GET_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrStationaryReferenceSpaceGenerationIdResultEXT"> + <member values="XR_TYPE_STATIONARY_REFERENCE_SPACE_GENERATION_ID_RESULT_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrUuid</type> <name>generationId</name></member> + </type> + + <!-- XR_ANDROID_spatial_discovery_bounds --> + <type category="struct" name="XrSpatialBoundsSpherefANDROID" structextends="XrSpatialDiscoverySnapshotCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_BOUNDS_SPHEREF_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrSpheref</type> <name>sphere</name></member> + </type> + <type category="struct" name="XrSpatialBoundsBoxfANDROID" structextends="XrSpatialDiscoverySnapshotCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_BOUNDS_BOXF_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrBoxf</type> <name>box</name></member> + </type> + <type category="struct" name="XrSpatialBoundsFrustumfANDROID" structextends="XrSpatialDiscoverySnapshotCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_BOUNDS_FRUSTUMF_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrFrustumf</type> <name>frustum</name></member> + </type> + + <!-- XR_ML_system_notifications --> + <type category="struct" name="XrSystemNotificationsSetInfoML"> + <member values="XR_TYPE_SYSTEM_NOTIFICATIONS_SET_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>suppressNotifications</name></member> + </type> + + <!-- XR_BD_spatial_audio_rendering --> + <type category="struct" name="XrSpatialAudioRendererCreateInfoBD"> + <member values="XR_TYPE_SPATIAL_AUDIO_RENDERER_CREATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>framesPerBuffer</name></member> + <member><type>XrAudioSampleRateBD</type> <name>sampleRate</name></member> + </type> + + <type category="struct" name="XrAudioBufferBD"> + <member values="XR_TYPE_AUDIO_BUFFER_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAudioBufferChannelLayoutBD</type> <name>channelLayout</name></member> + <member><type>uint32_t</type> <name>bufferChannels</name></member> + <member><type>uint32_t</type> <name>bufferLength</name></member> + <member len="bufferLength"><type>float</type>* <name>buffer</name></member> + </type> + + <type category="struct" name="XrSoundObjectDirectivityCardioidBD" structextends="XrSoundObjectConfigBD"> + <member values="XR_TYPE_SOUND_OBJECT_DIRECTIVITY_CARDIOID_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>alpha</name></member> + <member><type>float</type> <name>order</name></member> + </type> + + <type category="struct" name="XrSoundObjectShapeSphereBD" structextends="XrSoundObjectConfigBD"> + <member values="XR_TYPE_SOUND_OBJECT_SHAPE_SPHERE_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>radius</name></member> + </type> + + <type category="struct" name="XrSoundObjectDistanceAttenuationBD"> + <member values="XR_TYPE_SOUND_OBJECT_DISTANCE_ATTENUATION_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSoundObjectDistanceAttenuationTypeBD</type> <name>distanceAttenuationType</name></member> + <member><type>float</type> <name>minAttenuationRange</name></member> + <member><type>float</type> <name>maxAttenuationRange</name></member> + <member><type>float</type> <name>referenceDistance</name></member> + <member><type>float</type> <name>rolloffFactor</name></member> + <member optional="true"><type>XrSoundObjectDistanceAttenuationCurveBD</type>* <name>customDistanceAttenuationCurve</name></member> + </type> + + <type category="struct" name="XrAttenuationCurvePointBD"> + <member><type>float</type> <name>distance</name></member> + <member><type>float</type> <name>gain</name></member> + </type> + + <type category="struct" name="XrSoundObjectDistanceAttenuationCurveBD"> + <member values="XR_TYPE_SOUND_OBJECT_DISTANCE_ATTENUATION_CURVE_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>curvePointCount</name></member> + <member len="curvePointCount"><type>XrAttenuationCurvePointBD</type>* <name>curvePoints</name></member> + </type> + + <type category="struct" name="XrSoundObjectConfigBD"> + <member values="XR_TYPE_SOUND_OBJECT_CONFIG_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>enabled</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>float</type> <name>mainVolume</name></member> + <member><type>float</type> <name>reflectionGain</name></member> + <member><type>XrBool32</type> <name>enableDoppler</name></member> + <member>const <type>XrSoundObjectDistanceAttenuationBD</type>* <name>directSoundAttenuation</name></member> + <member>const <type>XrSoundObjectDistanceAttenuationBD</type>* <name>indirectSoundAttenuation</name></member> + </type> + + <type category="struct" name="XrSoundFieldConfigBD"> + <member values="XR_TYPE_SOUND_FIELD_CONFIG_BD"> <type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>enabled</name></member> + <member><type>XrQuaternionf</type> <name>orientation</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>float</type> <name>mainVolume</name></member> + <member><type>float</type> <name>lfeGain</name></member> + </type> + + <type category="struct" name="XrSoundFieldChannelDefinitionSurroundBD" structextends="XrSoundFieldConfigBD"> + <member values="XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_SURROUND_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSoundFieldChannelMaskSurroundBD</type> <name>channelMask</name></member> + </type> + + <type category="struct" name="XrSoundFieldChannelDefinitionAmbixBD" structextends="XrSoundFieldConfigBD"> + <member values="XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_AMBIX_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSoundFieldChannelMaskAmbixBD</type> <name>channelMask</name></member> + </type> + + <type category="struct" name="XrSoundFieldChannelDefinitionFumaBD" structextends="XrSoundFieldConfigBD"> + <member values="XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_FUMA_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSoundFieldChannelMaskFumaBD</type> <name>channelMask</name></member> + </type> + + <type category="struct" name="XrSoundTriangleMeshBD"> + <member values="XR_TYPE_SOUND_TRIANGLE_MESH_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>vertexCount</name></member> + <member len="vertexCount"><type>XrVector3f</type>* <name>vertices</name></member> + <member><type>uint32_t</type> <name>indexCount</name></member> + <member len="indexCount"><type>uint32_t</type>* <name>indices</name></member> + </type> + + <type category="struct" name="XrSoundObstacleConfigBD"> + <member values="XR_TYPE_SOUND_OBSTACLE_CONFIG_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>enabled</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>uint32_t</type> <name>materialCount</name></member> + <member len="materialCount"><type>XrSoundObstacleMaterialBD</type>* <name>materials</name></member> + </type> + + <type category="struct" name="XrSoundObstacleMaterialConfigBD"> + <member values="XR_TYPE_SOUND_OBSTACLE_MATERIAL_CONFIG_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSoundObstacleMaterialTypeBD</type> <name>materialType</name></member> + <member><type>uint32_t</type> <name>bandCount</name></member> + <member len="bandCount"><type>float</type>* <name>bandFrequencies</name></member> + <member len="bandCount"><type>float</type>* <name>bandAbsorptions</name></member> + <member len="bandCount"><type>float</type>* <name>bandScatterings</name></member> + <member len="bandCount"><type>float</type>* <name>bandTransmissions</name></member> + </type> + + <!-- XR_ML_spatial_anchors --> + <type category="struct" name="XrSpatialAnchorsCreateInfoBaseHeaderML"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsCreateInfoFromPoseML" parentstruct="XrSpatialAnchorsCreateInfoBaseHeaderML"> + <member values="XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_POSE_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrPosef</type> <name>poseInBaseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <type category="struct" name="XrCreateSpatialAnchorsCompletionML" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_CREATE_SPATIAL_ANCHORS_COMPLETION_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrResult</type> <name>futureResult</name></member> + <member optional="true"><type>uint32_t</type> <name>spaceCount</name></member> + <member optional="true" len="spaceCount"><type>XrSpace</type>* <name>spaces</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorStateML"> + <member values="XR_TYPE_SPATIAL_ANCHOR_STATE_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrSpatialAnchorConfidenceML</type> <name>confidence</name></member> + </type> + + <!-- XR_ML_spatial_anchors_storage --> + <type category="struct" name="XrSpatialAnchorsCreateStorageInfoML"> + <member values="XR_TYPE_SPATIAL_ANCHORS_CREATE_STORAGE_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsQueryInfoBaseHeaderML"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsQueryInfoRadiusML" parentstruct="XrSpatialAnchorsQueryInfoBaseHeaderML"> + <member values="XR_TYPE_SPATIAL_ANCHORS_QUERY_INFO_RADIUS_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrVector3f</type> <name>center</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>float</type> <name>radius</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsQueryCompletionML" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_ANCHORS_QUERY_COMPLETION_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrResult</type> <name>futureResult</name></member> + <member optional="true"><type>uint32_t</type> <name>uuidCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>uuidCountOutput</name></member> + <member optional="true" len="uuidCapacityInput"><type>XrUuidEXT</type>* <name>uuids</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsCreateInfoFromUuidsML" parentstruct="XrSpatialAnchorsCreateInfoBaseHeaderML"> + <member values="XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_UUIDS_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialAnchorsStorageML</type> <name>storage</name></member> + <member><type>uint32_t</type> <name>uuidCount</name></member> + <member len="uuidCount">const <type>XrUuidEXT</type>* <name>uuids</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsPublishInfoML"> + <member values="XR_TYPE_SPATIAL_ANCHORS_PUBLISH_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>anchorCount</name></member> + <member len="anchorCount">const <type>XrSpace</type>* <name>anchors</name></member> + <member><type>uint64_t</type> <name>expiration</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsPublishCompletionML" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_ANCHORS_PUBLISH_COMPLETION_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>uint32_t</type> <name>uuidCount</name></member> + <member len="uuidCount"><type>XrUuidEXT</type>* <name>uuids</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsDeleteInfoML"> + <member values="XR_TYPE_SPATIAL_ANCHORS_DELETE_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>uuidCount</name></member> + <member len="uuidCount">const <type>XrUuidEXT</type>* <name>uuids</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsDeleteCompletionML" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_ANCHORS_DELETE_COMPLETION_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsUpdateExpirationInfoML"> + <member values="XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>uuidCount</name></member> + <member len="uuidCount">const <type>XrUuidEXT</type>* <name>uuids</name></member> + <member><type>uint64_t</type> <name>expiration</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsUpdateExpirationCompletionML" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_COMPLETION_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorCompletionResultML"> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsPublishCompletionDetailsML" structextends="XrSpatialAnchorsPublishCompletionML"> + <member values="XR_TYPE_SPATIAL_ANCHORS_PUBLISH_COMPLETION_DETAILS_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>resultCount</name></member> + <member len="resultCount"><type>XrSpatialAnchorCompletionResultML</type>* <name>results</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsDeleteCompletionDetailsML" structextends="XrSpatialAnchorsDeleteCompletionML"> + <member values="XR_TYPE_SPATIAL_ANCHORS_DELETE_COMPLETION_DETAILS_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>resultCount</name></member> + <member len="resultCount"><type>XrSpatialAnchorCompletionResultML</type>* <name>results</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsUpdateExpirationCompletionDetailsML" structextends="XrSpatialAnchorsUpdateExpirationCompletionML"> + <member values="XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_COMPLETION_DETAILS_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>resultCount</name></member> + <member len="resultCount"><type>XrSpatialAnchorCompletionResultML</type>* <name>results</name></member> + </type> + + <!-- XR_ML_world_mesh_detection --> + <type category="struct" name="XrWorldMeshDetectorCreateInfoML"> + <member values="XR_TYPE_WORLD_MESH_DETECTOR_CREATE_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrWorldMeshStateRequestInfoML"> + <member values="XR_TYPE_WORLD_MESH_STATE_REQUEST_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrPosef</type> <name>boundingBoxCenter</name></member> + <member><type>XrExtent3DfEXT</type> <name>boundingBoxExtents</name></member> + </type> + + <type category="struct" name="XrWorldMeshBlockStateML"> + <member values="XR_TYPE_WORLD_MESH_BLOCK_STATE_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + <member><type>XrPosef</type> <name>meshBoundingBoxCenter</name></member> + <member><type>XrExtent3DfEXT</type> <name>meshBoundingBoxExtents</name></member> + <member><type>XrTime</type> <name>lastUpdateTime</name></member> + <member><type>XrWorldMeshBlockStatusML</type> <name>status</name></member> + </type> + + <type category="struct" name="XrWorldMeshStateRequestCompletionML" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_WORLD_MESH_STATE_REQUEST_COMPLETION_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member optional="true"><type>XrTime</type> <name>timestamp</name></member> + <member optional="true"><type>uint32_t</type> <name>meshBlockStateCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>meshBlockStateCountOutput</name></member> + <member optional="true" len="meshBlockStateCapacityInput"><type>XrWorldMeshBlockStateML</type>* <name>meshBlockStates</name></member> + </type> + + <type category="struct" name="XrWorldMeshBufferRecommendedSizeInfoML"> + <member values="XR_TYPE_WORLD_MESH_BUFFER_RECOMMENDED_SIZE_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>maxBlockCount</name></member> + </type> + + <type category="struct" name="XrWorldMeshBufferSizeML"> + <member values="XR_TYPE_WORLD_MESH_BUFFER_SIZE_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>size</name></member> + </type> + + <type category="struct" name="XrWorldMeshBufferML"> + <member values="XR_TYPE_WORLD_MESH_BUFFER_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>bufferSize</name></member> + <member len="bufferSize"><type>void</type>* <name>buffer</name></member> + </type> + + <type category="struct" name="XrWorldMeshBlockRequestML"> + <member values="XR_TYPE_WORLD_MESH_BLOCK_REQUEST_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + <member><type>XrWorldMeshDetectorLodML</type> <name>lod</name></member> + </type> + + <type category="struct" name="XrWorldMeshGetInfoML"> + <member values="XR_TYPE_WORLD_MESH_GET_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrWorldMeshDetectorFlagsML</type> <name>flags</name></member> + <member><type>float</type> <name>fillHoleLength</name></member> + <member><type>float</type> <name>disconnectedComponentArea</name></member> + <member><type>uint32_t</type> <name>blockCount</name></member> + <member len="blockCount"><type>XrWorldMeshBlockRequestML</type>* <name>blocks</name></member> + </type> + + <type category="struct" name="XrWorldMeshBlockML"> + <member values="XR_TYPE_WORLD_MESH_BLOCK_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + <member><type>XrWorldMeshBlockResultML</type> <name>blockResult</name></member> + <member><type>XrWorldMeshDetectorLodML</type> <name>lod</name></member> + <member><type>XrWorldMeshDetectorFlagsML</type> <name>flags</name></member> + <member><type>uint32_t</type> <name>indexCount</name></member> + <member len="indexCount"><type>uint16_t</type>* <name>indexBuffer</name></member> + <member><type>uint32_t</type> <name>vertexCount</name></member> + <member len="vertexCount"><type>XrVector3f</type>* <name>vertexBuffer</name></member> + <member><type>uint32_t</type> <name>normalCount</name></member> + <member len="normalCount"><type>XrVector3f</type>* <name>normalBuffer</name></member> + <member><type>uint32_t</type> <name>confidenceCount</name></member> + <member len="confidenceCount"><type>float</type>* <name>confidenceBuffer</name></member> + </type> + + <type category="struct" name="XrWorldMeshRequestCompletionInfoML"> + <member values="XR_TYPE_WORLD_MESH_REQUEST_COMPLETION_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>meshSpace</name></member> + <member><type>XrTime</type> <name>meshSpaceLocateTime</name></member> + </type> + + <type category="struct" name="XrWorldMeshRequestCompletionML" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_WORLD_MESH_REQUEST_COMPLETION_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>uint32_t</type> <name>blockCount</name></member> + <member len="blockCount"><type>XrWorldMeshBlockML</type>* <name>blocks</name></member> + </type> + + + <!-- XR_META_passthrough_layer_resumed_event --> + <type category="struct" name="XrEventDataPassthroughLayerResumedMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_PASSTHROUGH_LAYER_RESUMED_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPassthroughLayerFB</type> <name>layer</name></member> + </type> + + <!-- XR_EXT_render_model --> + <type category="struct" name="XrRenderModelCreateInfoEXT"> + <member values="XR_TYPE_RENDER_MODEL_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrRenderModelIdEXT</type> <name>renderModelId</name></member> + <member optional="true"><type>uint32_t</type> <name>gltfExtensionCount</name></member> + <member optional="true" len="gltfExtensionCount,null-terminated">const <type>char</type>* const* <name>gltfExtensions</name></member> + </type> + <type category="struct" name="XrRenderModelPropertiesGetInfoEXT"> + <member values="XR_TYPE_RENDER_MODEL_PROPERTIES_GET_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrRenderModelPropertiesEXT" returnedonly="true"> + <member values="XR_TYPE_RENDER_MODEL_PROPERTIES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrUuidEXT</type> <name>cacheId</name></member> + <member><type>uint32_t</type> <name>animatableNodeCount</name></member> + </type> + <type category="struct" name="XrRenderModelSpaceCreateInfoEXT"> + <member values="XR_TYPE_RENDER_MODEL_SPACE_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrRenderModelEXT</type> <name>renderModel</name></member> + </type> + <type category="struct" name="XrRenderModelAssetCreateInfoEXT"> + <member values="XR_TYPE_RENDER_MODEL_ASSET_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrUuidEXT</type> <name>cacheId</name></member> + </type> + <type category="struct" name="XrRenderModelAssetDataGetInfoEXT"> + <member values="XR_TYPE_RENDER_MODEL_ASSET_DATA_GET_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrRenderModelAssetDataEXT"> + <member values="XR_TYPE_RENDER_MODEL_ASSET_DATA_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>bufferCountOutput</name></member> + <member optional="true" len="bufferCapacityInput"><type>uint8_t</type>* <name>buffer</name></member> + </type> + <type category="struct" name="XrRenderModelAssetPropertiesGetInfoEXT"> + <member values="XR_TYPE_RENDER_MODEL_ASSET_PROPERTIES_GET_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrRenderModelAssetNodePropertiesEXT"> + <member><type>char</type> <name>uniqueName</name>[<enum>XR_MAX_RENDER_MODEL_ASSET_NODE_NAME_SIZE_EXT</enum>]</member> + </type> + <type category="struct" name="XrRenderModelAssetPropertiesEXT"> + <member values="XR_TYPE_RENDER_MODEL_ASSET_PROPERTIES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>nodePropertyCount</name></member> + <member len="nodePropertyCount"><type>XrRenderModelAssetNodePropertiesEXT</type>* <name>nodeProperties</name></member> + </type> + <type category="struct" name="XrRenderModelStateGetInfoEXT"> + <member values="XR_TYPE_RENDER_MODEL_STATE_GET_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>displayTime</name></member> + </type> + <type category="struct" name="XrRenderModelNodeStateEXT"> + <member><type>XrPosef</type> <name>nodePose</name></member> + <member><type>XrBool32</type> <name>isVisible</name></member> + </type> + <type category="struct" name="XrRenderModelStateEXT"> + <member values="XR_TYPE_RENDER_MODEL_STATE_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>nodeStateCount</name></member> + <member optional="true" len="nodeStateCount"><type>XrRenderModelNodeStateEXT</type>* <name>nodeStates</name></member> + </type> + + <!-- XR_EXT_interaction_render_model --> + <type category="struct" name="XrInteractionRenderModelIdsEnumerateInfoEXT"> + <member values="XR_TYPE_INTERACTION_RENDER_MODEL_IDS_ENUMERATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrInteractionRenderModelSubactionPathInfoEXT"> + <member values="XR_TYPE_INTERACTION_RENDER_MODEL_SUBACTION_PATH_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrInteractionRenderModelTopLevelUserPathGetInfoEXT"> + <member values="XR_TYPE_INTERACTION_RENDER_MODEL_TOP_LEVEL_USER_PATH_GET_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>topLevelUserPathCount</name></member> + <member len="topLevelUserPathCount">const <type>XrPath</type>* <name>topLevelUserPaths</name></member> + </type> + <type category="struct" name="XrEventDataInteractionRenderModelsChangedEXT" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_INTERACTION_RENDER_MODELS_CHANGED_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <!-- XR_BD_spatial_sensing --> + <type category="struct" name="XrSystemSpatialSensingPropertiesBD" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_SPATIAL_SENSING_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSpatialSensing</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentGetInfoBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_COMPONENT_GET_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialEntityIdBD</type> <name>entityId</name></member> + <member><type>XrSpatialEntityComponentTypeBD</type> <name>componentType</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentDataBaseHeaderBD"> + <member><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrSpatialEntityLocationGetInfoBD" structextends="XrSpatialEntityComponentGetInfoBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_LOCATION_GET_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentDataLocationBD" structextends="XrSpatialEntityComponentDataBaseHeaderBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_LOCATION_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrSpaceLocation</type> <name>location</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentDataSemanticBD" structextends="XrSpatialEntityComponentDataBaseHeaderBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_SEMANTIC_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>labelCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>labelCountOutput</name></member> + <member optional="true" len="labelCapacityInput"><type>XrSemanticLabelBD</type>* <name>labels</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentDataBoundingBox2DBD" structextends="XrSpatialEntityComponentDataBaseHeaderBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_BOUNDING_BOX_2D_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrRect2Df</type> <name>boundingBox2D</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentDataPolygonBD" structextends="XrSpatialEntityComponentDataBaseHeaderBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_POLYGON_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCountOutput</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector2f</type>* <name>vertices</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentDataBoundingBox3DBD" structextends="XrSpatialEntityComponentDataBaseHeaderBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_BOUNDING_BOX_3D_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBoxf</type> <name>boundingBox3D</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentDataTriangleMeshBD" structextends="XrSpatialEntityComponentDataBaseHeaderBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_TRIANGLE_MESH_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCountOutput</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector3f</type>* <name>vertices</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCountOutput</name></member> + <member optional="true" len="indexCapacityInput"><type>uint16_t</type>* <name>indices</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentDataSphereBD" structextends="XrSpatialEntityComponentDataBaseHeaderBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_SPHERE_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrSpheref</type> <name>sphere</name></member> + </type> + + <type category="struct" name="XrSenseDataProviderCreateInfoBD"> + <member values="XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSenseDataProviderTypeBD</type> <name>providerType</name></member> + </type> + + <type category="struct" name="XrSenseDataProviderStartInfoBD"> + <member values="XR_TYPE_SENSE_DATA_PROVIDER_START_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrEventDataSenseDataProviderStateChangedBD" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SENSE_DATA_PROVIDER_STATE_CHANGED_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSenseDataProviderBD</type> <name>provider</name></member> + <member><type>XrSenseDataProviderStateBD</type> <name>newState</name></member> + </type> + + <type category="struct" name="XrEventDataSenseDataUpdatedBD" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SENSE_DATA_UPDATED_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSenseDataProviderBD</type> <name>provider</name></member> + </type> + + <type category="struct" name="XrSenseDataQueryInfoBD"> + <member values="XR_TYPE_SENSE_DATA_QUERY_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrSenseDataFilterUuidBD" structextends="XrSenseDataQueryInfoBD"> + <member values="XR_TYPE_SENSE_DATA_FILTER_UUID_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>uuidCount</name></member> + <member len="uuidCount">const <type>XrUuidEXT</type>* <name>uuids</name></member> + </type> + + <type category="struct" name="XrSenseDataFilterSemanticBD" structextends="XrSenseDataQueryInfoBD"> + <member values="XR_TYPE_SENSE_DATA_FILTER_SEMANTIC_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>labelCount</name></member> + <member len="labelCount">const <type>XrSemanticLabelBD</type>* <name>labels</name></member> + </type> + + <type category="struct" name="XrSenseDataQueryCompletionBD" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_SENSE_DATA_QUERY_COMPLETION_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>XrSenseDataSnapshotBD</type> <name>snapshot</name></member> + </type> + + <type category="struct" name="XrQueriedSenseDataGetInfoBD"> + <member values="XR_TYPE_QUERIED_SENSE_DATA_GET_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrQueriedSenseDataBD"> + <member values="XR_TYPE_QUERIED_SENSE_DATA_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>stateCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>stateCountOutput</name></member> + <member optional="true" len="stateCapacityInput"><type>XrSpatialEntityStateBD</type>* <name>states</name></member> + </type> + + <type category="struct" name="XrSpatialEntityStateBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_STATE_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrSpatialEntityIdBD</type> <name>entityId</name></member> + <member><type>XrTime</type> <name>lastUpdateTime</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + </type> + + <type category="struct" name="XrSpatialEntityAnchorCreateInfoBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_ANCHOR_CREATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSenseDataSnapshotBD</type> <name>snapshot</name></member> + <member><type>XrSpatialEntityIdBD</type> <name>entityId</name></member> + </type> + + <type category="struct" name="XrAnchorSpaceCreateInfoBD"> + <member values="XR_TYPE_ANCHOR_SPACE_CREATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAnchorBD</type> <name>anchor</name></member> + <member><type>XrPosef</type> <name>poseInAnchorSpace</name></member> + </type> + + <!-- XR_BD_spatial_anchor --> + <type category="struct" name="XrSystemSpatialAnchorPropertiesBD" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_SPATIAL_ANCHOR_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSpatialAnchor</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorCreateInfoBD"> + <member values="XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorCreateCompletionBD" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_ANCHOR_CREATE_COMPLETION_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + <member><type>XrAnchorBD</type> <name>anchor</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorPersistInfoBD"> + <member values="XR_TYPE_SPATIAL_ANCHOR_PERSIST_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPersistenceLocationBD</type> <name>location</name></member> + <member><type>XrAnchorBD</type> <name>anchor</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorUnpersistInfoBD"> + <member values="XR_TYPE_SPATIAL_ANCHOR_UNPERSIST_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPersistenceLocationBD</type> <name>location</name></member> + <member><type>XrAnchorBD</type> <name>anchor</name></member> + </type> + + <!-- XR_BD_spatial_anchor_sharing --> + <type category="struct" name="XrSystemSpatialAnchorSharingPropertiesBD" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_SPATIAL_ANCHOR_SHARING_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSpatialAnchorSharing</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorShareInfoBD"> + <member values="XR_TYPE_SPATIAL_ANCHOR_SHARE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAnchorBD</type> <name>anchor</name></member> + </type> + + <type category="struct" name="XrSharedSpatialAnchorDownloadInfoBD"> + <member values="XR_TYPE_SHARED_SPATIAL_ANCHOR_DOWNLOAD_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + </type> + + <!-- XR_BD_spatial_mesh --> + <type category="struct" name="XrSystemSpatialMeshPropertiesBD" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_SPATIAL_MESH_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSpatialMesh</name></member> + </type> + + <type category="struct" name="XrSenseDataProviderCreateInfoSpatialMeshBD" structextends="XrSenseDataProviderCreateInfoBD"> + <member values="XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_SPATIAL_MESH_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrSpatialMeshConfigFlagsBD</type> <name>configFlags</name></member> + <member><type>XrSpatialMeshLodBD</type> <name>lod</name></member> + </type> + + <!-- XR_BD_spatial_light_estimation --> + <type category="struct" name="XrSystemLightEstimationPropertiesBD" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_LIGHT_ESTIMATION_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsLightEstimation</name></member> + <member><type>XrBool32</type> <name>supportsEnvironmentTexture</name></member> + <member><type>XrBool32</type> <name>supportsSphericalHarmonics</name></member> + </type> + + <type category="struct" name="XrSenseDataProviderCreateInfoLightEstimationBD" structextends="XrSenseDataProviderCreateInfoBD"> + <member values="XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_LIGHT_ESTIMATION_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrLightEstimationCreateFlagsBD</type> <name>createFlags</name></member> + </type> + + <type category="struct" name="XrEnvironmentTextureCreateConfigInfoBD" structextends="XrSenseDataProviderCreateInfoBD"> + <member values="XR_TYPE_ENVIRONMENT_TEXTURE_CREATE_CONFIG_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrEnvironmentTexturePixelFormatBD</type> <name>pixelFormat</name></member> + <member><type>XrEnvironmentTextureResolutionBD</type> <name>resolution</name></member> + <member><type>XrEnvironmentTextureTransferTypeBD</type> <name>transferType</name></member> + </type> + + <type category="struct" name="XrLightEstimationDataEnvironmentTextureRawBD" structextends="XrSpatialEntityComponentDataLightEstimationBD"> + <member values="XR_TYPE_LIGHT_ESTIMATION_DATA_ENVIRONMENT_TEXTURE_RAW_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrEnvironmentTexturePixelFormatBD</type> <name>pixelFormat</name></member> + <member><type>uint32_t</type> <name>cubemapFaceBufferSize</name></member> + <member len="cubemapFaceBufferSize"><type>uint8_t</type>* <name>rightCubemapFaceBuffer</name></member> + <member len="cubemapFaceBufferSize"><type>uint8_t</type>* <name>leftCubemapFaceBuffer</name></member> + <member len="cubemapFaceBufferSize"><type>uint8_t</type>* <name>topCubemapFaceBuffer</name></member> + <member len="cubemapFaceBufferSize"><type>uint8_t</type>* <name>bottomCubemapFaceBuffer</name></member> + <member len="cubemapFaceBufferSize"><type>uint8_t</type>* <name>frontCubemapFaceBuffer</name></member> + <member len="cubemapFaceBufferSize"><type>uint8_t</type>* <name>backCubemapFaceBuffer</name></member> + </type> + + <type category="struct" name="XrLightEstimationDataSphericalHarmonicsBD" structextends="XrSpatialEntityComponentDataLightEstimationBD"> + <member values="XR_TYPE_LIGHT_ESTIMATION_DATA_SPHERICAL_HARMONICS_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSphericalHarmonicsKindBD</type> <name>kind</name></member> + <member optional="true"><type>uint32_t</type> <name>coefficientCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>coefficientCountOutput</name></member> + <member optional="true" len="coefficientCapacityInput"> <type>float</type>* <name>coefficients</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentDataLightEstimationBD" structextends="XrSpatialEntityComponentDataBaseHeaderBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_LIGHT_ESTIMATION_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>isValid</name></member> + </type> + + + <!-- XR_BD_spatial_scene --> + <type category="struct" name="XrSystemSpatialScenePropertiesBD" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_SPATIAL_SCENE_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSpatialScene</name></member> + </type> + + <type category="struct" name="XrSceneCaptureInfoBD"> + <member values="XR_TYPE_SCENE_CAPTURE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <!-- XR_BD_spatial_plane --> + <type category="struct" name="XrSystemSpatialPlanePropertiesBD" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_SPATIAL_PLANE_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSpatialPlane</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentDataPlaneOrientationBD" structextends="XrSpatialEntityComponentDataBaseHeaderBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_PLANE_ORIENTATION_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrPlaneOrientationBD</type> <name>orientation</name></member> + </type> + + <type category="struct" name="XrSenseDataFilterPlaneOrientationBD" structextends="XrSenseDataQueryInfoBD"> + <member values="XR_TYPE_SENSE_DATA_FILTER_PLANE_ORIENTATION_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>orientationCount</name></member> + <member len="orientationCount"><type>XrPlaneOrientationBD</type>* <name>orientations</name></member> + </type> + + <!-- XR_BD_dynamic_object_tracking --> + <type category="struct" name="XrSystemDynamicObjectTrackingPropertiesBD" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_DYNAMIC_OBJECT_TRACKING_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsDynamicObjectTracking</name></member> + </type> + + <type category="struct" name="XrSenseDataProviderCreateInfoDynamicObjectBD" structextends="XrSenseDataProviderCreateInfoBD"> + <member values="XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_DYNAMIC_OBJECT_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>trackingTypeCount</name></member> + <member len="trackingTypeCount">const <type>XrDynamicObjectTypeBD</type>* <name>trackingTypes</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentDataDynamicObjectBD" structextends="XrSpatialEntityComponentDataBaseHeaderBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_DYNAMIC_OBJECT_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrDynamicObjectDataBD</type> <name>data</name></member> + </type> + + <type category="struct" name="XrDynamicObjectDataBD"> + <member values="XR_TYPE_DYNAMIC_OBJECT_DATA_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrDynamicObjectTypeBD</type> <name>objectType</name></member> + </type> + + <type category="struct" name="XrSenseDataFilterDynamicObjectTypeBD" structextends="XrSenseDataQueryInfoBD"> + <member values="XR_TYPE_SENSE_DATA_FILTER_DYNAMIC_OBJECT_TYPE_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>typeCount</name></member> + <member len="typeCount">const <type>XrDynamicObjectTypeBD</type>* <name>types</name></member> + </type> + + + <!-- XR_BD_dynamic_object_keyboard --> + <type category="struct" name="XrSystemDynamicObjectKeyboardPropertiesBD" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_DYNAMIC_OBJECT_KEYBOARD_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsDynamicObjectKeyboard</name></member> + </type> + + <!-- XR_BD_dynamic_object_mouse --> + <type category="struct" name="XrSystemDynamicObjectMousePropertiesBD" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_DYNAMIC_OBJECT_MOUSE_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsDynamicObjectMouse</name></member> + </type> + + <!-- XR_META_simultaneous_hands_and_controllers --> + <type category="struct" name="XrSystemSimultaneousHandsAndControllersPropertiesMETA" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_SIMULTANEOUS_HANDS_AND_CONTROLLERS_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSimultaneousHandsAndControllers</name></member> + </type> + <type category="struct" name="XrSimultaneousHandsAndControllersTrackingResumeInfoMETA"> + <member values="XR_TYPE_SIMULTANEOUS_HANDS_AND_CONTROLLERS_TRACKING_RESUME_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrSimultaneousHandsAndControllersTrackingPauseInfoMETA"> + <member values="XR_TYPE_SIMULTANEOUS_HANDS_AND_CONTROLLERS_TRACKING_PAUSE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <!-- XR_EXT_loader_init_properties --> + <type category="struct" name="XrLoaderInitInfoPropertiesEXT" parentstruct="XrLoaderInitInfoBaseHeaderKHR" structextends="XrLoaderInitInfoBaseHeaderKHR"> + <member values="XR_TYPE_LOADER_INIT_INFO_PROPERTIES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>propertyValueCount</name></member> + <member len="propertyValueCount">const <type>XrLoaderInitPropertyValueEXT</type>* <name>propertyValues</name></member> + </type> + + <type category="struct" name="XrLoaderInitPropertyValueEXT"> + <member len="null-terminated">const <type>char</type>* <name>name</name></member> + <member len="null-terminated">const <type>char</type>* <name>value</name></member> + </type> + + <!-- XR_ANDROID_spatial_discovery_raycast --> + <type category="struct" name="XrSpatialCapabilityConfigurationDepthRaycastANDROID" parentstruct="XrSpatialCapabilityConfigurationBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_DEPTH_RAYCAST_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialCapabilityEXT</type> <name>capability</name></member> + <member><type>uint32_t</type> <name>enabledComponentCount</name></member> + <member len="enabledComponentCount">const <type>XrSpatialComponentTypeEXT</type>* <name>enabledComponents</name></member> + </type> + + <type category="struct" name="XrSpatialRaycastInfoANDROID" structextends="XrSpatialDiscoverySnapshotCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_RAYCAST_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrVector3f</type> <name>origin</name></member> + <member><type>XrVector3f</type> <name>direction</name></member> + <member optional="true"><type>float</type> <name>maxDistance</name></member> + </type> + + <type category="struct" name="XrSpatialRaycastResultDataANDROID"> + <member><type>XrPosef</type> <name>hitPose</name></member> + <member><type>float</type> <name>distanceSquared</name></member> + </type> + + <type category="struct" name="XrSpatialComponentRaycastResultListANDROID" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_RAYCAST_RESULT_LIST_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>raycastResultCount</name></member> + <member len="raycastResultCount"><type>XrSpatialRaycastResultDataANDROID</type>* <name>raycastResults</name></member> + </type> + + <type category="struct" name="XrSpatialRaycastSnapshotCreateInfoANDROID"> + <member values="XR_TYPE_SPATIAL_RAYCAST_SNAPSHOT_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>componentTypeCount</name></member> + <member optional="true" len="componentTypeCount">const <type>XrSpatialComponentTypeEXT</type>* <name>componentTypes</name></member> + <member>const <type>XrSpatialRaycastInfoANDROID</type>* <name>raycastInfo</name></member> + </type> + + <!-- XR_EXT_spatial_marker_tracking --> + <type category="struct" name="XrSpatialCapabilityConfigurationArucoMarkerEXT" parentstruct="XrSpatialCapabilityConfigurationBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ARUCO_MARKER_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialCapabilityEXT</type> <name>capability</name></member> + <member><type>uint32_t</type> <name>enabledComponentCount</name></member> + <member len="enabledComponentCount">const <type>XrSpatialComponentTypeEXT</type>* <name>enabledComponents</name></member> + <member><type>XrSpatialMarkerArucoDictEXT</type> <name>arUcoDict</name></member> + </type> + + <type category="struct" name="XrSpatialCapabilityConfigurationAprilTagEXT" parentstruct="XrSpatialCapabilityConfigurationBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_APRIL_TAG_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialCapabilityEXT</type> <name>capability</name></member> + <member><type>uint32_t</type> <name>enabledComponentCount</name></member> + <member len="enabledComponentCount">const <type>XrSpatialComponentTypeEXT</type>* <name>enabledComponents</name></member> + <member><type>XrSpatialMarkerAprilTagDictEXT</type> <name>aprilDict</name></member> + </type> + + <type category="struct" name="XrSpatialCapabilityConfigurationQrCodeEXT" parentstruct="XrSpatialCapabilityConfigurationBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_QR_CODE_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialCapabilityEXT</type> <name>capability</name></member> + <member><type>uint32_t</type> <name>enabledComponentCount</name></member> + <member len="enabledComponentCount">const <type>XrSpatialComponentTypeEXT</type>* <name>enabledComponents</name></member> + </type> + + <type category="struct" name="XrSpatialCapabilityConfigurationMicroQrCodeEXT" parentstruct="XrSpatialCapabilityConfigurationBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_MICRO_QR_CODE_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialCapabilityEXT</type> <name>capability</name></member> + <member><type>uint32_t</type> <name>enabledComponentCount</name></member> + <member len="enabledComponentCount">const <type>XrSpatialComponentTypeEXT</type>* <name>enabledComponents</name></member> + </type> + + <type category="struct" name="XrSpatialMarkerSizeEXT" structextends="XrSpatialCapabilityConfigurationArucoMarkerEXT,XrSpatialCapabilityConfigurationAprilTagEXT,XrSpatialCapabilityConfigurationQrCodeEXT,XrSpatialCapabilityConfigurationMicroQrCodeEXT"> + <member values="XR_TYPE_SPATIAL_MARKER_SIZE_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>markerSideLength</name></member> + </type> + + <type category="struct" name="XrSpatialMarkerStaticOptimizationEXT" structextends="XrSpatialCapabilityConfigurationArucoMarkerEXT,XrSpatialCapabilityConfigurationAprilTagEXT,XrSpatialCapabilityConfigurationQrCodeEXT,XrSpatialCapabilityConfigurationMicroQrCodeEXT"> + <member values="XR_TYPE_SPATIAL_MARKER_STATIC_OPTIMIZATION_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>optimizeForStaticMarker</name></member> + </type> + + <type category="struct" name="XrSpatialMarkerDataEXT"> + <member><type>XrSpatialCapabilityEXT</type> <name>capability</name></member> + <member><type>uint32_t</type> <name>markerId</name></member> + <member><type>XrSpatialBufferEXT</type> <name>data</name></member> + </type> + + <type category="struct" name="XrSpatialComponentMarkerListEXT" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_MARKER_LIST_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>markerCount</name></member> + <member len="markerCount"><type>XrSpatialMarkerDataEXT</type>* <name>markers</name></member> + </type> + + <!-- XR_META_tile_properties_hint --> + <type name="XrExtent3DiMETA" category="struct"> + <member><type>int32_t</type> <name>width</name></member> + <member><type>int32_t</type> <name>height</name></member> + <member><type>int32_t</type> <name>depth</name></member> + </type> + <type name="XrTilePropertiesMETA" category="struct"> + <member values="XR_TYPE_TILE_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrExtent3DiMETA</type> <name>tileDimensions</name></member> + <member><type>XrExtent2Di</type> <name>apronDimensions</name></member> + <member><type>XrOffset2Di</type> <name>origin</name></member> + </type> + <type name="XrTilePropertiesHintMETA" category="struct"> + <member values="XR_TYPE_TILE_PROPERTIES_HINT_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>propertiesCount</name></member> + <member len="propertiesCount">const <type>XrTilePropertiesMETA</type>* <name>properties</name></member> + </type> + + <!-- XR_BD_facial_simulation --> + <type category="struct" name="XrSystemFacialSimulationPropertiesBD" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_FACIAL_SIMULATION_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsFaceTracking</name></member> + </type> + + <type category="struct" name="XrFaceTrackerCreateInfoBD"> + <member values="XR_TYPE_FACE_TRACKER_CREATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrFacialSimulationModeBD</type> <name>mode</name></member> + </type> + + <type category="struct" name="XrFacialSimulationDataGetInfoBD"> + <member values="XR_TYPE_FACIAL_SIMULATION_DATA_GET_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <type category="struct" name="XrFacialSimulationDataBD"> + <member values="XR_TYPE_FACIAL_SIMULATION_DATA_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>faceExpressionWeightCount</name></member> + <member len="faceExpressionWeightCount"><type>float</type>* <name>faceExpressionWeights</name></member> + <member><type>XrBool32</type> <name>isUpperFaceDataValid</name></member> + <member><type>XrBool32</type> <name>isLowerFaceDataValid</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <type category="struct" name="XrLipExpressionDataBD" structextends="XrFacialSimulationDataBD"> + <member values="XR_TYPE_LIP_EXPRESSION_DATA_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>lipsyncExpressionWeightCount</name></member> + <member len="lipsyncExpressionWeightCount"><type>float</type>* <name>lipsyncExpressionWeights</name></member> + </type> + + <!-- XR_ANDROID_geospatial --> + <type name="XrGeospatialTrackerStateANDROID" category="enum"/> + <type name="XrGeospatialPoseFlagBitsANDROID" category="enum"/> + <type name="XrVPSAvailabilityANDROID" category="enum"/> + + <type category="struct" name="XrSystemGeospatialPropertiesANDROID" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_GEOSPATIAL_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsGeospatial</name></member> + </type> + <type category="struct" name="XrGeospatialTrackerCreateInfoANDROID"> + <member values="XR_TYPE_GEOSPATIAL_TRACKER_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrEventDataGeospatialTrackerStateChangedANDROID" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_GEOSPATIAL_TRACKER_STATE_CHANGED_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrGeospatialTrackerANDROID</type> <name>geospatialTracker</name></member> + <member><type>XrGeospatialTrackerStateANDROID</type> <name>state</name></member> + <member><type>XrResult</type> <name>initializationResult</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrGeospatialPoseANDROID"> + <member><type>XrQuaternionf</type> <name>eastUpSouthOrientation</name></member> + <member><type>double</type> <name>latitude</name></member> + <member><type>double</type> <name>longitude</name></member> + <member><type>double</type> <name>altitude</name></member> + </type> + <type category="struct" name="XrGeospatialPoseFromPoseLocateInfoANDROID"> + <member values="XR_TYPE_GEOSPATIAL_POSE_FROM_POSE_LOCATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrGeospatialPoseResultANDROID" returnedonly="true"> + <member values="XR_TYPE_GEOSPATIAL_POSE_RESULT_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrGeospatialPoseFlagsANDROID</type> <name>poseFlags</name></member> + <member><type>XrGeospatialPoseANDROID</type> <name>geospatialPose</name></member> + <member><type>double</type> <name>horizontalAccuracy</name></member> + <member><type>double</type> <name>verticalAccuracy</name></member> + <member><type>double</type> <name>orientationYawAccuracy</name></member> + </type> + <type category="struct" name="XrGeospatialPoseLocateInfoANDROID"> + <member values="XR_TYPE_GEOSPATIAL_POSE_LOCATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrGeospatialPoseANDROID</type> <name>geospatialPose</name></member> + </type> + <type category="struct" name="XrVPSAvailabilityCheckCompletionANDROID" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_VPS_AVAILABILITY_CHECK_COMPLETION_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>XrVPSAvailabilityANDROID</type> <name>availability</name></member> + </type> + + <!-- XR_ANDROID_geospatial_anchor --> + <type name="XrSurfaceAnchorTypeANDROID" category="enum"/> + <type category="struct" name="XrSystemGeospatialAnchorPropertiesANDROID" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_GEOSPATIAL_ANCHOR_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>maxSurfaceAnchorCount</name></member> + </type> + <type category="struct" name="XrGeospatialTrackerAnchorTrackingInfoANDROID" structextends="XrGeospatialTrackerCreateInfoANDROID"> + <member values="XR_TYPE_GEOSPATIAL_TRACKER_ANCHOR_TRACKING_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>shouldTrackPlanes</name></member> + </type> + <type category="struct" name="XrGeospatialAnchorCreateInfoANDROID"> + <member values="XR_TYPE_GEOSPATIAL_ANCHOR_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrGeospatialTrackerANDROID</type> <name>geospatialTracker</name></member> + <member><type>XrGeospatialPoseANDROID</type> <name>geospatialPose</name></member> + </type> + <type category="struct" name="XrSurfaceAnchorCreateInfoANDROID"> + <member values="XR_TYPE_SURFACE_ANCHOR_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrGeospatialTrackerANDROID</type> <name>geospatialTracker</name></member> + <member><type>XrSurfaceAnchorTypeANDROID</type> <name>surfaceAnchorType</name></member> + <member><type>XrQuaternionf</type> <name>eastUpSouthOrientation</name></member> + <member><type>double</type> <name>latitude</name></member> + <member><type>double</type> <name>longitude</name></member> + <member><type>double</type> <name>altitudeRelativeToSurface</name></member> + </type> + <type category="struct" name="XrSurfaceAnchorCreateCompletionANDROID" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_SURFACE_ANCHOR_CREATE_COMPLETION_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>XrSpatialEntityIdEXT</type> <name>anchorEntityId</name></member> + </type> + + <!-- XR_ANDROID_trackables_image --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrTrackableImageDatabaseANDROID</name>)</type> + + <type name="XrTrackableImageFormatANDROID" category="enum"/> + <type name="XrTrackableImageTrackingModeANDROID" category="enum"/> + + <type category="struct" name="XrSystemImageTrackingPropertiesANDROID" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_IMAGE_TRACKING_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsImageTracking</name></member> + <member><type>XrBool32</type> <name>supportsPhysicalSizeEstimation</name></member> + <member><type>uint32_t</type> <name>maxTrackedImageCount</name></member> + <member><type>uint32_t</type> <name>maxLoadedImageCount</name></member> + </type> + + <type category="struct" name="XrTrackableImageDatabaseEntryANDROID"> + <member values="XR_TYPE_TRACKABLE_IMAGE_DATABASE_ENTRY_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTrackableImageTrackingModeANDROID</type> <name>trackingMode</name></member> + <member optional="true"><type>float</type> <name>physicalWidth</name></member> + <member><type>uint32_t</type> <name>imageWidth</name></member> + <member><type>uint32_t</type> <name>imageHeight</name></member> + <member><type>XrTrackableImageFormatANDROID</type> <name>format</name></member> + <member><type>uint32_t</type> <name>bufferSize</name></member> + <member len="bufferSize">const <type>uint8_t</type>* <name>buffer</name></member> + </type> + + <type category="struct" name="XrTrackableImageDatabaseCreateInfoANDROID"> + <member values="XR_TYPE_TRACKABLE_IMAGE_DATABASE_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>entryCount</name></member> + <member len="entryCount">const <type>XrTrackableImageDatabaseEntryANDROID</type>* <name>entries</name></member> + </type> + + <type category="struct" name="XrCreateTrackableImageDatabaseCompletionANDROID" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_CREATE_TRACKABLE_IMAGE_DATABASE_COMPLETION_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>XrTrackableImageDatabaseANDROID</type> <name>database</name></member> + </type> + + <type category="struct" name="XrTrackableImageConfigurationANDROID"> + <member values="XR_TYPE_TRACKABLE_IMAGE_CONFIGURATION_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>databaseCount</name></member> + <member len="databaseCount">const <type>XrTrackableImageDatabaseANDROID</type>* <name>databases</name></member> + </type> + + <type category="struct" name="XrTrackableImageANDROID"> + <member values="XR_TYPE_TRACKABLE_IMAGE_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTrackingStateANDROID</type> <name>trackingState</name></member> + <member><type>XrTime</type> <name>lastUpdatedTime</name></member> + <member><type>XrTrackableImageDatabaseANDROID</type> <name>database</name></member> + <member><type>uint32_t</type> <name>databaseEntryIndex</name></member> + <member><type>XrPosef</type> <name>centerPose</name></member> + <member><type>XrExtent2Df</type> <name>extents</name></member> + </type> + + <type category="struct" name="XrEventDataImageTrackingLostANDROID" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_IMAGE_TRACKING_LOST_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <!-- XR_ANDROID_spatial_object_tracking --> + <type category="struct" name="XrSpatialCapabilityConfigurationObjectTrackingANDROID" parentstruct="XrSpatialCapabilityConfigurationBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_OBJECT_TRACKING_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialCapabilityEXT</type> <name>capability</name></member> + <member><type>uint32_t</type> <name>enabledComponentCount</name></member> + <member len="enabledComponentCount">const <type>XrSpatialComponentTypeEXT</type>* <name>enabledComponents</name></member> + <member><type>uint32_t</type> <name>activeSemanticLabelCount</name></member> + <member len="activeSemanticLabelCount">const <type>XrSpatialObjectSemanticLabelANDROID</type>* <name>activeSemanticLabels</name></member> + </type> + + <type category="struct" name="XrSpatialComponentObjectSemanticLabelListANDROID" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_OBJECT_SEMANTIC_LABEL_LIST_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>semanticLabelCount</name></member> + <member len="semanticLabelCount"><type>XrSpatialObjectSemanticLabelANDROID</type>* <name>semanticLabels</name></member> + </type> + + <!-- XR_ANDROID_spatial_entity_bound_anchor --> + <type category="struct" name="XrSpatialAnchorParentANDROID" structextends="XrSpatialAnchorCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_ANCHOR_PARENT_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialEntityIdEXT</type> <name>parentId</name></member> + </type> + + <!-- XR_ANDROID_spatial_anchor_space --> + <type category="struct" name="XrSpatialAnchorSpaceFromIdCreateInfoANDROID"> + <member values="XR_TYPE_SPATIAL_ANCHOR_SPACE_FROM_ID_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialEntityIdEXT</type> <name>anchorEntityId</name></member> + </type> + + <!-- XR_ANDROID_spatial_component_subsumed_by --> + <type category="struct" name="XrSpatialDiscoveryUniqueEntitiesFilterANDROID" structextends="XrSpatialDiscoverySnapshotCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_DISCOVERY_UNIQUE_ENTITIES_FILTER_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrSpatialComponentSubsumedByListANDROID" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_SUBSUMED_BY_LIST_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>subsumedUniqueIdCount</name></member> + <member len="subsumedUniqueIdCount"><type>XrSpatialEntityIdEXT</type>* <name>subsumedUniqueIds</name></member> + </type> + + <!-- XR_EXT_view_configuration_views_change --> + <type category="struct" name="XrEventDataViewConfigurationViewsChangedEXT" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_VIEW_CONFIGURATION_VIEWS_CHANGED_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSystemId</type> <name>systemId</name></member> + <member><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></member> + </type> + + <!-- XR_EXT_interaction_profile_battery_state_display --> + <type bitvalues="XrBatteryStateDisplayStateFlagBitsEXT" category="bitmask">typedef <type>XrFlags64</type> <name>XrBatteryStateDisplayStateFlagsEXT</name>;</type> + <type name="XrBatteryStateDisplayStateFlagBitsEXT" category="enum"/> + + <type category="struct" name="XrBatteryStateDisplayEXT" structextends="XrInteractionProfileState"> + <member values="XR_TYPE_BATTERY_STATE_DISPLAY_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBatteryStateDisplayStateFlagsEXT</type> <name>stateFlags</name></member> + <member><type>float</type> <name>batteryLevel</name></member> + </type> + + <!-- XR_META_environment_raycast --> + <type category="struct" name="XrSystemEnvironmentRaycastPropertiesMETA" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_ENVIRONMENT_RAYCAST_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsEnvironmentRaycast</name></member> + </type> + + <type category="struct" name="XrEnvironmentRaycasterCreateInfoMETA"> + <member values="XR_TYPE_ENVIRONMENT_RAYCASTER_CREATE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrEnvironmentRaycasterCreateCompletionMETA" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_ENVIRONMENT_RAYCASTER_CREATE_COMPLETION_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>XrEnvironmentRaycasterMETA</type> <name>environmentRaycaster</name></member> + </type> + + <type category="struct" name="XrEnvironmentRaycastFilterBaseHeaderMETA"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrEnvironmentRaycastFilterDistanceMETA" parentstruct="XrEnvironmentRaycastFilterBaseHeaderMETA"> + <member values="XR_TYPE_ENVIRONMENT_RAYCAST_FILTER_DISTANCE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>maxDistance</name></member> + </type> + + <type category="struct" name="XrEnvironmentRaycastHitGetInfoMETA"> + <member values="XR_TYPE_ENVIRONMENT_RAYCAST_HIT_GET_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrVector3f</type> <name>origin</name></member> + <member><type>XrVector3f</type> <name>direction</name></member> + <member optional="true"><type>uint32_t</type> <name>filterCount</name></member> + <member optional="true" len="filterCount">const <type>XrEnvironmentRaycastFilterBaseHeaderMETA</type>* const * <name>filters</name></member> + </type> + + <type category="struct" name="XrEnvironmentRaycastHitMETA"> + <member values="XR_TYPE_ENVIRONMENT_RAYCAST_HIT_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrEnvironmentRaycastHitStatusMETA</type> <name>status</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + + <!-- XR_META_hand_tracking_unextrapolated_poses --> + <type category="struct" name="XrHandTrackingUnextrapolatedPosesRequestMETA" structextends="XrHandJointsLocateInfoEXT"> + <member values="XR_TYPE_HAND_TRACKING_UNEXTRAPOLATED_POSES_REQUEST_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrHandTrackingUnextrapolatedPosesMETA" structextends="XrHandJointLocationsEXT" returnedonly="true"> + <member values="XR_TYPE_HAND_TRACKING_UNEXTRAPOLATED_POSES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>captureTime</name></member> + </type> + + <!-- XR_QCOM_hand_tracking_gesture --> + <type category="struct" name="XrHandGestureQCOM"> + <member><type>XrHandGestureTypeQCOM</type> <name>gesture</name></member> + <member><type>float</type> <name>gestureRatio</name></member> + <member><type>float</type> <name>flipRatio</name></member> + </type> + + <!-- XR_META_hand_tracking_frequency_hint --> + <type category="enum" name="XrHandTrackingFrequencyHintMETA"/> + + <!-- XR_EXT_haptic_parametric --> + <type category="struct" name="XrHapticParametricPropertiesEXT"> + <member values="XR_TYPE_HAPTIC_PARAMETRIC_PROPERTIES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrDuration</type> <name>idealFrameSubmissionRate</name></member> + <member><type>XrDuration</type> <name>minimumFirstFrameDuration</name></member> + <member><type>float</type> <name>minFrequencyHz</name></member> + <member><type>float</type> <name>maxFrequencyHz</name></member> + </type> + + <type category="struct" name="XrHapticParametricPointEXT"> + <member><type>XrDuration</type> <name>time</name></member> + <member><type>float</type> <name>value</name></member> + </type> + + <type category="struct" name="XrHapticParametricTransientEXT"> + <member><type>XrDuration</type> <name>time</name></member> + <member><type>float</type> <name>amplitude</name></member> + <member><type>float</type> <name>frequency</name></member> + </type> + + <type category="struct" name="XrHapticParametricVibrationEXT" parentstruct="XrHapticBaseHeader"> + <member values="XR_TYPE_HAPTIC_PARAMETRIC_VIBRATION_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + + <member><type>uint32_t</type> <name>amplitudePointCount</name></member> + <member len="amplitudePointCount">const <type>XrHapticParametricPointEXT</type>* <name>amplitudePoints</name></member> + + <member optional="true"><type>uint32_t</type> <name>frequencyPointCount</name></member> + <member optional="true" len="frequencyPointCount">const <type>XrHapticParametricPointEXT</type>* <name>frequencyPoints</name></member> + + <member optional="true"><type>uint32_t</type> <name>transientCount</name></member> + <member optional="true" len="transientCount">const <type>XrHapticParametricTransientEXT</type>* <name>transients</name></member> + + <member><type>float</type> <name>minFrequencyHz</name></member> + <member><type>float</type> <name>maxFrequencyHz</name></member> + + <member><type>XrHapticParametricStreamFrameTypeEXT</type> <name>streamFrameType</name></member> + </type> + + <type category="struct" name="XrSystemHapticParametricPropertiesEXT" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_HAPTIC_PARAMETRIC_PROPERTIES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsParametricHaptics</name></member> + </type> + + <!-- XR_ANDROID_google_cloud_auth --> + <type name="XrGoogleCloudAuthErrorANDROID" category="enum"/> + <type category="struct" name="XrGoogleCloudAuthInfoBaseHeaderANDROID"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrGoogleCloudAuthInfoApiKeyANDROID" parentstruct="XrGoogleCloudAuthInfoBaseHeaderANDROID"> + <member values="XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_API_KEY_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member len="null-terminated">const <type>char</type>* <name>apiKey</name></member> + </type> + <type category="struct" name="XrGoogleCloudAuthInfoTokenANDROID" parentstruct="XrGoogleCloudAuthInfoBaseHeaderANDROID"> + <member values="XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_TOKEN_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member len="null-terminated">const <type>char</type>* <name>authToken</name></member> + </type> + <type category="struct" name="XrGoogleCloudAuthInfoKeylessANDROID" parentstruct="XrGoogleCloudAuthInfoBaseHeaderANDROID"> + <member values="XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_KEYLESS_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrGoogleCloudAuthErrorResultANDROID" structextends="XrGoogleCloudAuthInfoBaseHeaderANDROID"> + <member values="XR_TYPE_GOOGLE_CLOUD_AUTH_ERROR_RESULT_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrGoogleCloudAuthErrorANDROID</type> <name>error</name></member> + </type> + + <!-- XR_SONY_swapchain_color_space --> + <type category="struct" name="XrColorSpacesEnumerateInfoSONY"> + <member values="XR_TYPE_COLOR_SPACES_ENUMERATE_INFO_SONY"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>int64_t</type> <name>format</name></member> + </type> + + <type category="struct" name="XrSwapchainCreateInfoColorSpaceSONY" structextends="XrSwapchainCreateInfo"> + <member values="XR_TYPE_SWAPCHAIN_CREATE_INFO_COLOR_SPACE_SONY"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrColorSpaceSONY</type> <name>colorSpace</name></member> + </type> + + <!-- XR_BD_camera_image --> + <type category="struct" name="XrAvailableCamerasEnumerateInfoBD"> + <member values="XR_TYPE_AVAILABLE_CAMERAS_ENUMERATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true">const <type>XrCameraPropertiesBD</type>* <name>properties</name></member> + <member optional="true">const <type>XrCameraCapabilitiesBD</type>* <name>capabilities</name></member> + </type> + <type category="struct" name="XrAvailableCameraBD" returnedonly="true"> + <member values="XR_TYPE_AVAILABLE_CAMERA_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrCameraIdBD</type> <name>cameraId</name></member> + </type> + <type category="struct" name="XrCameraPropertiesGetInfoBD"> + <member values="XR_TYPE_CAMERA_PROPERTIES_GET_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraIdBD</type> <name>cameraId</name></member> + </type> + <type category="struct" name="XrCameraPropertyBaseHeaderBD"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrCameraPropertiesBD"> + <member values="XR_TYPE_CAMERA_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>propertyCount</name></member> + <member len="propertyCount"><type>XrCameraPropertyBaseHeaderBD</type>** <name>properties</name></member> + </type> + <type category="struct" name="XrCameraPropertyFacingBD" parentstruct="XrCameraPropertyBaseHeaderBD"> + <member values="XR_TYPE_CAMERA_PROPERTY_FACING_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraFacingBD</type> <name>facing</name></member> + </type> + <type category="struct" name="XrCameraPropertyPositionBD" parentstruct="XrCameraPropertyBaseHeaderBD"> + <member values="XR_TYPE_CAMERA_PROPERTY_POSITION_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraPositionBD</type> <name>position</name></member> + </type> + <type category="struct" name="XrCameraPropertyCameraTypeBD" parentstruct="XrCameraPropertyBaseHeaderBD"> + <member values="XR_TYPE_CAMERA_PROPERTY_CAMERA_TYPE_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraTypeBD</type> <name>cameraType</name></member> + </type> + <type category="struct" name="XrCameraSupportedCapabilitiesGetInfoBD"> + <member values="XR_TYPE_CAMERA_SUPPORTED_CAPABILITIES_GET_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraIdBD</type> <name>id</name></member> + </type> + <type category="struct" name="XrCameraSupportedCapabilityBaseHeaderBD" returnedonly="true"> + <member><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrCameraSupportedCapabilitiesBD"> + <member values="XR_TYPE_CAMERA_SUPPORTED_CAPABILITIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>capabilityCount</name></member> + <member len="capabilityCount"><type>XrCameraSupportedCapabilityBaseHeaderBD</type>** <name>capabilities</name></member> + </type> + <type category="struct" name="XrCameraCapabilityBaseHeaderBD"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrCameraCapabilitiesBD"> + <member values="XR_TYPE_CAMERA_CAPABILITIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>capabilityCount</name></member> + <member len="capabilityCount"><type>XrCameraCapabilityBaseHeaderBD</type>** <name>capabilities</name></member> + </type> + <type category="struct" name="XrCameraCapabilityTypesEnumerateInfoBD"> + <member values="XR_TYPE_CAMERA_CAPABILITY_TYPES_ENUMERATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraIdBD</type> <name>cameraId</name></member> + </type> + <type category="struct" name="XrCameraCapabilityTypesBD"> + <member values="XR_TYPE_CAMERA_CAPABILITY_TYPES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>capabilityTypeCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>capabilityTypeCountOutput</name></member> + <member optional="true" len="capabilityTypeCapacityInput"><type>XrCameraCapabilityTypeBD</type>* <name>capabilityTypes</name></member> + </type> + <type category="struct" name="XrCameraPropertyTypesEnumerateInfoBD"> + <member values="XR_TYPE_CAMERA_PROPERTY_TYPES_ENUMERATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraIdBD</type> <name>cameraId</name></member> + </type> + <type category="struct" name="XrCameraPropertyTypesBD"> + <member values="XR_TYPE_CAMERA_PROPERTY_TYPES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>propertyTypeCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>propertyTypeCountOutput</name></member> + <member optional="true" len="propertyTypeCapacityInput"><type>XrCameraPropertyTypeBD</type>* <name>propertyTypes</name></member> + </type> + <type category="struct" name="XrCameraImageResolutionAndFrameRateBD"> + <member><type>XrExtent2Di</type> <name>resolution</name></member> + <member><type>uint32_t</type> <name>frameRate</name></member> + </type> + <type category="struct" name="XrCameraSupportedCapabilityImageResolutionAndFrameRateBD" parentstruct="XrCameraSupportedCapabilityBaseHeaderBD" returnedonly="true"> + <member values="XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_IMAGE_RESOLUTION_AND_FRAME_RATE_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>resolutionAndFrameRateCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>resolutionAndFrameRateCountOutput</name></member> + <member optional="true" len="resolutionAndFrameRateCapacityInput"><type>XrCameraImageResolutionAndFrameRateBD</type>* <name>resolutionAndFrameRates</name></member> + </type> + <type category="struct" name="XrCameraCapabilityImageResolutionAndFrameRateBD" parentstruct="XrCameraCapabilityBaseHeaderBD"> + <member values="XR_TYPE_CAMERA_CAPABILITY_IMAGE_RESOLUTION_AND_FRAME_RATE_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrExtent2Di</type> <name>resolution</name></member> + <member><type>uint32_t</type> <name>frameRate</name></member> + </type> + <type category="struct" name="XrCameraSupportedCapabilityDataTransferTypeBD" parentstruct="XrCameraSupportedCapabilityBaseHeaderBD" returnedonly="true"> + <member values="XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_DATA_TRANSFER_TYPE_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>transferTypeCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>transferTypeCountOutput</name></member> + <member optional="true" len="transferTypeCapacityInput"><type>XrCameraDataTransferTypeBD</type>* <name>transferTypes</name></member> + </type> + <type category="struct" name="XrCameraCapabilityDataTransferTypeBD" parentstruct="XrCameraCapabilityBaseHeaderBD"> + <member values="XR_TYPE_CAMERA_CAPABILITY_DATA_TRANSFER_TYPE_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraDataTransferTypeBD</type> <name>transferType</name></member> + </type> + <type category="struct" name="XrCameraSupportedCapabilityImageFormatBD" parentstruct="XrCameraSupportedCapabilityBaseHeaderBD" returnedonly="true"> + <member values="XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_IMAGE_FORMAT_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>formatCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>formatCountOutput</name></member> + <member optional="true" len="formatCapacityInput"><type>XrCameraImageFormatBD</type>* <name>formats</name></member> + </type> + <type category="struct" name="XrCameraCapabilityImageFormatBD" parentstruct="XrCameraCapabilityBaseHeaderBD"> + <member values="XR_TYPE_CAMERA_CAPABILITY_IMAGE_FORMAT_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraImageFormatBD</type> <name>format</name></member> + </type> + <type category="struct" name="XrCameraSupportedCapabilityCameraModelBD" parentstruct="XrCameraSupportedCapabilityBaseHeaderBD" returnedonly="true"> + <member values="XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_CAMERA_MODEL_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>modelCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>modelCountOutput</name></member> + <member optional="true" len="modelCapacityInput"><type>XrCameraModelBD</type>* <name>models</name></member> + </type> + <type category="struct" name="XrCameraCapabilityCameraModelBD" parentstruct="XrCameraCapabilityBaseHeaderBD"> + <member values="XR_TYPE_CAMERA_CAPABILITY_CAMERA_MODEL_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraModelBD</type> <name>model</name></member> + </type> + <type category="struct" name="XrCameraDeviceCreateInfoBD"> + <member values="XR_TYPE_CAMERA_DEVICE_CREATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraIdBD</type> <name>cameraId</name></member> + </type> + <type category="struct" name="XrCreateCameraDeviceCompletionBD" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_CREATE_CAMERA_DEVICE_COMPLETION_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>XrCameraDeviceBD</type> <name>device</name></member> + </type> + <type category="struct" name="XrCameraCaptureSessionCreateInfoBD"> + <member values="XR_TYPE_CAMERA_CAPTURE_SESSION_CREATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraDeviceBD</type> <name>camera</name></member> + <member><type>uint32_t</type> <name>configCount</name></member> + <member len="configCount">const <type>XrCameraCapabilityBaseHeaderBD</type>* const* <name>configs</name></member> + </type> + <type category="struct" name="XrCreateCameraCaptureSessionCompletionBD" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_CREATE_CAMERA_CAPTURE_SESSION_COMPLETION_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>XrCameraCaptureSessionBD</type> <name>captureSession</name></member> + </type> + <type category="struct" name="XrCameraIntrinsicsBD" structextends="XrCameraImageDataBaseHeaderBD"> + <member values="XR_TYPE_CAMERA_INTRINSICS_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrVector2f</type> <name>focalLength</name></member> + <member><type>XrVector2f</type> <name>principalPoint</name></member> + <member><type>XrVector2f</type> <name>fov</name></member> + </type> + <type category="struct" name="XrCameraExtrinsicsBD" structextends="XrCameraImageDataBaseHeaderBD"> + <member values="XR_TYPE_CAMERA_EXTRINSICS_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrCameraCaptureBeginInfoBD"> + <member values="XR_TYPE_CAMERA_CAPTURE_BEGIN_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrCameraImageAcquireInfoBD"> + <member values="XR_TYPE_CAMERA_IMAGE_ACQUIRE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>lastCaptureTime</name></member> + </type> + <type category="struct" name="XrCameraImageBD"> + <member values="XR_TYPE_CAMERA_IMAGE_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>available</name></member> + <member><type>XrTime</type> <name>captureTime</name></member> + <member><type>XrCameraImageIdBD</type> <name>imageId</name></member> + </type> + <type category="struct" name="XrCameraImageDataBaseHeaderBD"> + <member><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrCameraImageDataRawBufferBD" parentstruct="XrCameraImageDataBaseHeaderBD"> + <member values="XR_TYPE_CAMERA_IMAGE_DATA_RAW_BUFFER_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>width</name></member> + <member><type>uint32_t</type> <name>height</name></member> + <member><type>uint32_t</type> <name>stride</name></member> + <member><type>uint32_t</type> <name>bytesPerPixel</name></member> + <member><type>uint32_t</type> <name>pixelStride</name></member> + <member><type>uint32_t</type> <name>bufferSize</name></member> + <member len="bufferSize"><type>uint8_t</type>* <name>buffer</name></member> + </type> + + <!-- XR_SONY_hdr_metadata --> + <type category="struct" name="XrHdrMetadataSONY"> + <member values="XR_TYPE_HDR_METADATA_SONY"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrXYColorSONY</type> <name>displayPrimaryRed</name></member> + <member><type>XrXYColorSONY</type> <name>displayPrimaryGreen</name></member> + <member><type>XrXYColorSONY</type> <name>displayPrimaryBlue</name></member> + <member><type>XrXYColorSONY</type> <name>whitePoint</name></member> + <member><type>float</type> <name>maxLuminance</name></member> + <member><type>float</type> <name>minLuminance</name></member> + <member><type>float</type> <name>maxContentLightLevel</name></member> + <member><type>float</type> <name>maxFrameAverageLightLevel</name></member> + </type> + + <type category="struct" name="XrXYColorSONY"> + <member><type>float</type> <name>x</name></member> + <member><type>float</type> <name>y</name></member> + </type> + + </types> + + + <!-- SECTION: OpenXR enumerant (token) definitions. --> + + <enums name="API Constants" comment="Misc. hardcoded constants - not an enumerated type"> + <!-- This is part of the header boilerplate --> + <enum value="1" name="XR_TRUE"/> + <enum value="0" name="XR_FALSE"/> + <enum value="128" name="XR_MAX_EXTENSION_NAME_SIZE"/> + <enum value="256" name="XR_MAX_API_LAYER_NAME_SIZE"/> + <enum value="256" name="XR_MAX_API_LAYER_DESCRIPTION_SIZE"/> + <enum value="256" name="XR_MAX_SYSTEM_NAME_SIZE"/> + <enum value="128" name="XR_MAX_APPLICATION_NAME_SIZE"/> + <enum value="128" name="XR_MAX_ENGINE_NAME_SIZE"/> + <enum value="128" name="XR_MAX_RUNTIME_NAME_SIZE"/> + <enum value="256" name="XR_MAX_PATH_LENGTH"/> + <enum value="64" name="XR_MAX_STRUCTURE_NAME_SIZE"/> + <enum value="64" name="XR_MAX_RESULT_STRING_SIZE"/> + <enum value="32" name="XR_MAX_GRAPHICS_APIS_SUPPORTED"/> + <enum value="64" name="XR_MAX_ACTION_SET_NAME_SIZE"/> + <enum value="64" name="XR_MAX_ACTION_NAME_SIZE"/> + <enum value="128" name="XR_MAX_LOCALIZED_ACTION_SET_NAME_SIZE"/> + <enum value="128" name="XR_MAX_LOCALIZED_ACTION_NAME_SIZE"/> + <enum value="16" name="XR_UUID_SIZE"/> + </enums> + + <!-- Unlike OpenGL, most tokens in OpenXR are actual typed enumerants in + their own numeric namespaces. The "name" attribute is the C enum + type name, and is pulled in from a <type> definition above + (slightly clunky, but retains the type / enum distinction). "type" + attributes of "enum" or "bitmask" indicate that these values should + be generated inside an appropriate definition. --> + + <enums name="XrStructureType" type="enum" comment="Structure type enumerant"> + <enum value="0" name="XR_TYPE_UNKNOWN"/> + <enum value="1" name="XR_TYPE_API_LAYER_PROPERTIES"/> + <enum value="2" name="XR_TYPE_EXTENSION_PROPERTIES"/> + <enum value="3" name="XR_TYPE_INSTANCE_CREATE_INFO"/> + <enum value="4" name="XR_TYPE_SYSTEM_GET_INFO"/> + <enum value="5" name="XR_TYPE_SYSTEM_PROPERTIES"/> + <enum value="6" name="XR_TYPE_VIEW_LOCATE_INFO"/> + <enum value="7" name="XR_TYPE_VIEW"/> + <enum value="8" name="XR_TYPE_SESSION_CREATE_INFO"/> + <enum value="9" name="XR_TYPE_SWAPCHAIN_CREATE_INFO"/> + <enum value="10" name="XR_TYPE_SESSION_BEGIN_INFO"/> + <enum value="11" name="XR_TYPE_VIEW_STATE"/> + <enum value="12" name="XR_TYPE_FRAME_END_INFO"/> + <enum value="13" name="XR_TYPE_HAPTIC_VIBRATION"/> + <enum value="16" name="XR_TYPE_EVENT_DATA_BUFFER"/> + <enum value="17" name="XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING"/> + <enum value="18" name="XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED"/> + <enum value="23" name="XR_TYPE_ACTION_STATE_BOOLEAN"/> + <enum value="24" name="XR_TYPE_ACTION_STATE_FLOAT"/> + <enum value="25" name="XR_TYPE_ACTION_STATE_VECTOR2F"/> + <enum value="27" name="XR_TYPE_ACTION_STATE_POSE"/> + <enum value="28" name="XR_TYPE_ACTION_SET_CREATE_INFO"/> + <enum value="29" name="XR_TYPE_ACTION_CREATE_INFO"/> + <enum value="32" name="XR_TYPE_INSTANCE_PROPERTIES"/> + <enum value="33" name="XR_TYPE_FRAME_WAIT_INFO"/> + <enum value="35" name="XR_TYPE_COMPOSITION_LAYER_PROJECTION"/> + <enum value="36" name="XR_TYPE_COMPOSITION_LAYER_QUAD"/> + <enum value="37" name="XR_TYPE_REFERENCE_SPACE_CREATE_INFO"/> + <enum value="38" name="XR_TYPE_ACTION_SPACE_CREATE_INFO"/> + <enum value="40" name="XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING"/> + <enum value="41" name="XR_TYPE_VIEW_CONFIGURATION_VIEW"/> + <enum value="42" name="XR_TYPE_SPACE_LOCATION"/> + <enum value="43" name="XR_TYPE_SPACE_VELOCITY"/> + <enum value="44" name="XR_TYPE_FRAME_STATE"/> + <enum value="45" name="XR_TYPE_VIEW_CONFIGURATION_PROPERTIES"/> + <enum value="46" name="XR_TYPE_FRAME_BEGIN_INFO"/> + <enum value="48" name="XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW"/> + <enum value="49" name="XR_TYPE_EVENT_DATA_EVENTS_LOST"/> + <enum value="51" name="XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING"/> + <enum value="52" name="XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED"/> + <enum value="53" name="XR_TYPE_INTERACTION_PROFILE_STATE"/> + <enum value="55" name="XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO"/> + <enum value="56" name="XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO"/> + <enum value="57" name="XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO"/> + <enum value="58" name="XR_TYPE_ACTION_STATE_GET_INFO"/> + <enum value="59" name="XR_TYPE_HAPTIC_ACTION_INFO"/> + <enum value="60" name="XR_TYPE_SESSION_ACTION_SETS_ATTACH_INFO"/> + <enum value="61" name="XR_TYPE_ACTIONS_SYNC_INFO"/> + <enum value="62" name="XR_TYPE_BOUND_SOURCES_FOR_ACTION_ENUMERATE_INFO"/> + <enum value="63" name="XR_TYPE_INPUT_SOURCE_LOCALIZED_NAME_GET_INFO"/> + </enums> + <enums name="XrResult" type="enum" comment="Error and return codes"> + <!-- Return codes for successful operation execution (positive values) --> + <enum value="0" name="XR_SUCCESS" comment="Function successfully completed."/> + <enum value="1" name="XR_TIMEOUT_EXPIRED" comment="The specified timeout time occurred before the operation could complete."/> + <enum value="3" name="XR_SESSION_LOSS_PENDING" comment="The session will be lost soon."/> + <enum value="4" name="XR_EVENT_UNAVAILABLE" comment="No event was available."/> + <enum value="7" name="XR_SPACE_BOUNDS_UNAVAILABLE" comment="The space's bounds are not known at the moment."/> + <enum value="8" name="XR_SESSION_NOT_FOCUSED" comment="The session is not in the focused state, and if spatial containers are enabled no spatial container exists that is interactable."/> + <enum value="9" name="XR_FRAME_DISCARDED" comment="A frame has been discarded from composition."/> + <!-- Error codes (negative values) --> + <enum value="-1" name="XR_ERROR_VALIDATION_FAILURE" comment="The function usage was invalid in some way."/> + <enum value="-2" name="XR_ERROR_RUNTIME_FAILURE" comment="The runtime failed to handle the function in an unexpected way that is not covered by another error result. "/> + <enum value="-3" name="XR_ERROR_OUT_OF_MEMORY" comment="A memory allocation has failed."/> + <enum value="-4" name="XR_ERROR_API_VERSION_UNSUPPORTED" comment="The runtime does not support the requested API version."/> + <enum value="-6" name="XR_ERROR_INITIALIZATION_FAILED" comment="Initialization of object could not be completed."/> + <enum value="-7" name="XR_ERROR_FUNCTION_UNSUPPORTED" comment="The requested function was not found or is otherwise unsupported."/> + <enum value="-8" name="XR_ERROR_FEATURE_UNSUPPORTED" comment="The requested feature is not supported."/> + <enum value="-9" name="XR_ERROR_EXTENSION_NOT_PRESENT" comment="A requested extension is not supported."/> + <enum value="-10" name="XR_ERROR_LIMIT_REACHED" comment="The runtime supports no more of the requested resource."/> + <enum value="-11" name="XR_ERROR_SIZE_INSUFFICIENT" comment="The supplied size was smaller than required."/> + <enum value="-12" name="XR_ERROR_HANDLE_INVALID" comment="A supplied object handle was invalid."/> + <enum value="-13" name="XR_ERROR_INSTANCE_LOST" comment="The slink:XrInstance was lost or could not be found. It will need to be destroyed and optionally recreated."/> + <enum value="-14" name="XR_ERROR_SESSION_RUNNING" comment="The session <<session-running, is already running>>."/> + <enum value="-16" name="XR_ERROR_SESSION_NOT_RUNNING" comment="The session <<session-not-running, is not yet running>>."/> + <enum value="-17" name="XR_ERROR_SESSION_LOST" comment="The slink:XrSession was lost. It will need to be destroyed and optionally recreated."/> + <enum value="-18" name="XR_ERROR_SYSTEM_INVALID" comment="The provided basetype:XrSystemId was invalid."/> + <enum value="-19" name="XR_ERROR_PATH_INVALID" comment="The provided basetype:XrPath was not valid."/> + <enum value="-20" name="XR_ERROR_PATH_COUNT_EXCEEDED" comment="The maximum number of supported semantic paths has been reached."/> + <enum value="-21" name="XR_ERROR_PATH_FORMAT_INVALID" comment="The semantic path character format is invalid."/> + <enum value="-22" name="XR_ERROR_PATH_UNSUPPORTED" comment="The semantic path is unsupported."/> + <enum value="-23" name="XR_ERROR_LAYER_INVALID" comment="The layer was NULL or otherwise invalid."/> + <enum value="-24" name="XR_ERROR_LAYER_LIMIT_EXCEEDED" comment="The number of specified layers is greater than the supported number."/> + <enum value="-25" name="XR_ERROR_SWAPCHAIN_RECT_INVALID" comment="The image rect was negatively sized or otherwise invalid."/> + <enum value="-26" name="XR_ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED" comment="The image format is not supported by the runtime or platform."/> + <enum value="-27" name="XR_ERROR_ACTION_TYPE_MISMATCH" comment="The API used to retrieve an action's state does not match the action's type."/> + <enum value="-28" name="XR_ERROR_SESSION_NOT_READY" comment="The session is not in the ready state."/> + <enum value="-29" name="XR_ERROR_SESSION_NOT_STOPPING" comment="The session is not in the stopping state."/> + <enum value="-30" name="XR_ERROR_TIME_INVALID" comment="The provided basetype:XrTime was zero, negative, or out of range."/> + <enum value="-31" name="XR_ERROR_REFERENCE_SPACE_UNSUPPORTED" comment="The specified reference space is not supported by the runtime or system."/> + <enum value="-32" name="XR_ERROR_FILE_ACCESS_ERROR" comment="The file could not be accessed."/> + <enum value="-33" name="XR_ERROR_FILE_CONTENTS_INVALID" comment="The file's contents were invalid."/> + <enum value="-34" name="XR_ERROR_FORM_FACTOR_UNSUPPORTED" comment="The specified form factor is not supported by the current runtime or platform."/> + <enum value="-35" name="XR_ERROR_FORM_FACTOR_UNAVAILABLE" comment="The specified form factor is supported, but the device is currently not available, e.g. not plugged in or powered off."/> + <enum value="-36" name="XR_ERROR_API_LAYER_NOT_PRESENT" comment="A requested API layer is not present or could not be loaded."/> + <enum value="-37" name="XR_ERROR_CALL_ORDER_INVALID" comment="The call was made without having made a previously required call."/> + <enum value="-38" name="XR_ERROR_GRAPHICS_DEVICE_INVALID" comment="The given graphics device is not in a valid state. The graphics device could be lost or initialized without meeting graphics requirements."/> + <enum value="-39" name="XR_ERROR_POSE_INVALID" comment="The supplied pose was invalid with respect to the requirements."/> + <enum value="-40" name="XR_ERROR_INDEX_OUT_OF_RANGE" comment="The supplied index was outside the range of valid indices."/> + <enum value="-41" name="XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED" comment="The specified view configuration type is not supported by the runtime or platform."/> + <enum value="-42" name="XR_ERROR_ENVIRONMENT_BLEND_MODE_UNSUPPORTED" comment="The specified environment blend mode is not supported by the runtime or platform."/> + <enum value="-44" name="XR_ERROR_NAME_DUPLICATED" comment="The name provided was a duplicate of an already-existing resource."/> + <enum value="-45" name="XR_ERROR_NAME_INVALID" comment="The name provided was invalid."/> + <enum value="-46" name="XR_ERROR_ACTIONSET_NOT_ATTACHED" comment="A referenced action set is not attached to the session."/> + <enum value="-47" name="XR_ERROR_ACTIONSETS_ALREADY_ATTACHED" comment="The session already has attached action sets."/> + <enum value="-48" name="XR_ERROR_LOCALIZED_NAME_DUPLICATED" comment="The localized name provided was a duplicate of an already-existing resource."/> + <enum value="-49" name="XR_ERROR_LOCALIZED_NAME_INVALID" comment="The localized name provided was invalid."/> + <enum value="-50" name="XR_ERROR_GRAPHICS_REQUIREMENTS_CALL_MISSING" comment="The ftext:xrGet*GraphicsRequirements call was not made before calling fname:xrCreateSession."/> + <enum value="-51" name="XR_ERROR_RUNTIME_UNAVAILABLE" comment="The loader was unable to find or load a runtime."/> + <unused start="-100"/> + </enums> + <enums name="XrObjectType" type="enum" comment="Enums to track objects of various types"> + <enum value="0" name="XR_OBJECT_TYPE_UNKNOWN"/> + <enum value="1" name="XR_OBJECT_TYPE_INSTANCE" comment="XrInstance"/> + <enum value="2" name="XR_OBJECT_TYPE_SESSION" comment="XrSession"/> + <enum value="3" name="XR_OBJECT_TYPE_SWAPCHAIN" comment="XrSwapchain"/> + <enum value="4" name="XR_OBJECT_TYPE_SPACE" comment="XrSpace"/> + <enum value="5" name="XR_OBJECT_TYPE_ACTION_SET" comment="XrActionSet"/> + <enum value="6" name="XR_OBJECT_TYPE_ACTION" comment="XrAction"/> + </enums> + <enums name="XrAndroidThreadTypeKHR" type="enum" comment="Android Thread Types"> + <enum value="1" name="XR_ANDROID_THREAD_TYPE_APPLICATION_MAIN_KHR"/> + <enum value="2" name="XR_ANDROID_THREAD_TYPE_APPLICATION_WORKER_KHR"/> + <enum value="3" name="XR_ANDROID_THREAD_TYPE_RENDERER_MAIN_KHR"/> + <enum value="4" name="XR_ANDROID_THREAD_TYPE_RENDERER_WORKER_KHR"/> + </enums> + <enums name="XrEyeVisibility" type="enum" comment="eye visibility selector"> + <enum value="0" name="XR_EYE_VISIBILITY_BOTH" comment="Display in both eyes."/> + <enum value="1" name="XR_EYE_VISIBILITY_LEFT" comment="Display in the left eye only."/> + <enum value="2" name="XR_EYE_VISIBILITY_RIGHT" comment="Display in the right eye only."/> + </enums> + <enums name="XrActionType" type="enum"> + <enum value="1" name="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <enum value="2" name="XR_ACTION_TYPE_FLOAT_INPUT"/> + <enum value="3" name="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <enum value="4" name="XR_ACTION_TYPE_POSE_INPUT"/> + <enum value="100" name="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </enums> + <enums name="XrReferenceSpaceType" type="enum"> + <enum value="1" name="XR_REFERENCE_SPACE_TYPE_VIEW"/> + <enum value="2" name="XR_REFERENCE_SPACE_TYPE_LOCAL"/> + <enum value="3" name="XR_REFERENCE_SPACE_TYPE_STAGE"/> + </enums> + <enums name="XrFormFactor" type="enum"> + <enum value="1" name="XR_FORM_FACTOR_HEAD_MOUNTED_DISPLAY"/> + <enum value="2" name="XR_FORM_FACTOR_HANDHELD_DISPLAY"/> + </enums> + <enums name="XrViewConfigurationType" type="enum"> + <enum value="1" name="XR_VIEW_CONFIGURATION_TYPE_PRIMARY_MONO"/> + <enum value="2" name="XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO"/> + </enums> + <enums name="XrEnvironmentBlendMode" type="enum"> + <enum value="1" name="XR_ENVIRONMENT_BLEND_MODE_OPAQUE"/> + <enum value="2" name="XR_ENVIRONMENT_BLEND_MODE_ADDITIVE"/> + <enum value="3" name="XR_ENVIRONMENT_BLEND_MODE_ALPHA_BLEND"/> + </enums> + <enums name="XrSessionState" type="enum"> + <enum value="0" name="XR_SESSION_STATE_UNKNOWN"/> + <enum value="1" name="XR_SESSION_STATE_IDLE"/> + <enum value="2" name="XR_SESSION_STATE_READY"/> + <enum value="3" name="XR_SESSION_STATE_SYNCHRONIZED"/> + <enum value="4" name="XR_SESSION_STATE_VISIBLE"/> + <enum value="5" name="XR_SESSION_STATE_FOCUSED"/> + <enum value="6" name="XR_SESSION_STATE_STOPPING"/> + <enum value="7" name="XR_SESSION_STATE_LOSS_PENDING"/> + <enum value="8" name="XR_SESSION_STATE_EXITING"/> + </enums> + + <!--enums for Perf setting EXT--> + <enums name="XrPerfSettingsLevelEXT" type="enum"> + <enum value="0" name="XR_PERF_SETTINGS_LEVEL_POWER_SAVINGS_EXT" comment="Performance settings hint used by the application to indicate that it enters a non-XR section (head-locked / static screen), during which power savings are to be prioritized"/> + <enum value="25" name="XR_PERF_SETTINGS_LEVEL_SUSTAINED_LOW_EXT" comment="Performance settings hint used by the application to indicate that it enters a low and stable complexity section, during which reducing power is more important than occasional late rendering frames"/> + <enum value="50" name="XR_PERF_SETTINGS_LEVEL_SUSTAINED_HIGH_EXT" comment="Performance settings hint used by the application to indicate that it enters a high or dynamic complexity section, during which the XR Runtime strives for consistent XR compositing and frame rendering within a thermally sustainable range"/> + <enum value="75" name="XR_PERF_SETTINGS_LEVEL_BOOST_EXT" comment="Performance settings hint used by the application to indicate that the application enters a section with very high complexity, during which the XR Runtime is allowed to step up beyond the thermally sustainable range"/> + </enums> + <enums name="XrPerfSettingsDomainEXT" type="enum"> + <enum value="1" name="XR_PERF_SETTINGS_DOMAIN_CPU_EXT" comment="Indicates that the performance settings or notification applies to CPU domain"/> + <enum value="2" name="XR_PERF_SETTINGS_DOMAIN_GPU_EXT" comment="Indicates that the performance settings or notification applies to GPU domain"/> + </enums> + <enums name="XrPerfSettingsSubDomainEXT" type="enum"> + <enum value="1" name="XR_PERF_SETTINGS_SUB_DOMAIN_COMPOSITING_EXT" comment="Indicates that the performance notification originates from the COMPOSITING sub-domain"/> + <enum value="2" name="XR_PERF_SETTINGS_SUB_DOMAIN_RENDERING_EXT" comment="Indicates that the performance notification originates from the RENDERING sub-domain"/> + <enum value="3" name="XR_PERF_SETTINGS_SUB_DOMAIN_THERMAL_EXT" comment="Indicates that the performance notification originates from the THERMAL sub-domain"/> + </enums> + <enums name="XrPerfSettingsNotificationLevelEXT" type="enum"> + <enum value="0" name="XR_PERF_SETTINGS_NOTIF_LEVEL_NORMAL_EXT" comment="Notifies that the sub-domain has reached a level where no further actions other than currently applied are necessary"/> + <enum value="25" name="XR_PERF_SETTINGS_NOTIF_LEVEL_WARNING_EXT" comment="Notifies that the sub-domain has reached an early warning level where the application should start proactive mitigation actions with the goal to return to the ename:XR_PERF_NOTIF_LEVEL_NORMAL level"/> + <enum value="75" name="XR_PERF_SETTINGS_NOTIF_LEVEL_IMPAIRED_EXT" comment="Notifies that the sub-domain has reached a critical level with significant performance degradation. The application should take drastic mitigation action"/> + </enums> + + <!--enums for XR_KHR_visibility_mask --> + <enums name="XrVisibilityMaskTypeKHR" type="enum" comment=""> + <enum value="1" name="XR_VISIBILITY_MASK_TYPE_HIDDEN_TRIANGLE_MESH_KHR" comment="exclusive mesh; indicates that which the viewer cannot see."/> + <enum value="2" name="XR_VISIBILITY_MASK_TYPE_VISIBLE_TRIANGLE_MESH_KHR" comment="inclusive mesh; indicates strictly that which the viewer can see."/> + <enum value="3" name="XR_VISIBILITY_MASK_TYPE_LINE_LOOP_KHR" comment="line loop; traces the outline of the area the viewer can see."/> + </enums> + + <!-- XR_EXT_hand_tracking --> + <enums name="XrHandEXT" type="enum"> + <enum value="1" name="XR_HAND_LEFT_EXT"/> + <enum value="2" name="XR_HAND_RIGHT_EXT"/> + </enums> + <enums name="XrHandJointEXT" type="enum"> + <enum value="0" name="XR_HAND_JOINT_PALM_EXT"/> + <enum value="1" name="XR_HAND_JOINT_WRIST_EXT"/> + <enum value="2" name="XR_HAND_JOINT_THUMB_METACARPAL_EXT"/> + <enum value="3" name="XR_HAND_JOINT_THUMB_PROXIMAL_EXT"/> + <enum value="4" name="XR_HAND_JOINT_THUMB_DISTAL_EXT"/> + <enum value="5" name="XR_HAND_JOINT_THUMB_TIP_EXT"/> + <enum value="6" name="XR_HAND_JOINT_INDEX_METACARPAL_EXT"/> + <enum value="7" name="XR_HAND_JOINT_INDEX_PROXIMAL_EXT"/> + <enum value="8" name="XR_HAND_JOINT_INDEX_INTERMEDIATE_EXT"/> + <enum value="9" name="XR_HAND_JOINT_INDEX_DISTAL_EXT"/> + <enum value="10" name="XR_HAND_JOINT_INDEX_TIP_EXT"/> + <enum value="11" name="XR_HAND_JOINT_MIDDLE_METACARPAL_EXT"/> + <enum value="12" name="XR_HAND_JOINT_MIDDLE_PROXIMAL_EXT"/> + <enum value="13" name="XR_HAND_JOINT_MIDDLE_INTERMEDIATE_EXT"/> + <enum value="14" name="XR_HAND_JOINT_MIDDLE_DISTAL_EXT"/> + <enum value="15" name="XR_HAND_JOINT_MIDDLE_TIP_EXT"/> + <enum value="16" name="XR_HAND_JOINT_RING_METACARPAL_EXT"/> + <enum value="17" name="XR_HAND_JOINT_RING_PROXIMAL_EXT"/> + <enum value="18" name="XR_HAND_JOINT_RING_INTERMEDIATE_EXT"/> + <enum value="19" name="XR_HAND_JOINT_RING_DISTAL_EXT"/> + <enum value="20" name="XR_HAND_JOINT_RING_TIP_EXT"/> + <enum value="21" name="XR_HAND_JOINT_LITTLE_METACARPAL_EXT"/> + <enum value="22" name="XR_HAND_JOINT_LITTLE_PROXIMAL_EXT"/> + <enum value="23" name="XR_HAND_JOINT_LITTLE_INTERMEDIATE_EXT"/> + <enum value="24" name="XR_HAND_JOINT_LITTLE_DISTAL_EXT"/> + <enum value="25" name="XR_HAND_JOINT_LITTLE_TIP_EXT"/> + </enums> + <enums name="XrHandJointSetEXT" type="enum"> + <enum value="0" name="XR_HAND_JOINT_SET_DEFAULT_EXT"/> + </enums> + + <!-- XR_EXT_hand_joints_motion_range --> + <enums name="XrHandJointsMotionRangeEXT" type="enum"> + <enum value="1" name="XR_HAND_JOINTS_MOTION_RANGE_UNOBSTRUCTED_EXT"/> + <enum value="2" name="XR_HAND_JOINTS_MOTION_RANGE_CONFORMING_TO_CONTROLLER_EXT"/> + </enums> + + <!-- XR_EXT_hand_tracking_data_source --> + <enums name="XrHandTrackingDataSourceEXT" type="enum"> + <enum value="1" name="XR_HAND_TRACKING_DATA_SOURCE_UNOBSTRUCTED_EXT" comment="This data source value indicates individual fingers and joints are tracked from unobstructed data source such as optical hand tracking, data gloves, or motion capture devices."/> + <enum value="2" name="XR_HAND_TRACKING_DATA_SOURCE_CONTROLLER_EXT" comment="This data source value indicates hand joints are inferred based on motion controller state."/> + </enums> + + <!-- flags for XR_EXT_frame_synthesis --> + <enums name="XrFrameSynthesisInfoFlagBitsEXT" type="bitmask"> + <enum bitpos="0" name="XR_FRAME_SYNTHESIS_INFO_USE_2D_MOTION_VECTOR_BIT_EXT" comment="2D motion vector will be used"/> + <enum bitpos="1" name="XR_FRAME_SYNTHESIS_INFO_REQUEST_RELAXED_FRAME_INTERVAL_BIT_EXT" comment="Request the runtime to relax the application's frame interval to allow additional render time"/> + </enums> + + <!-- XR_MSFT_hand_tracking_mesh --> + <enums name="XrHandPoseTypeMSFT" type="enum"> + <enum value="0" name="XR_HAND_POSE_TYPE_TRACKED_MSFT"/> + <enum value="1" name="XR_HAND_POSE_TYPE_REFERENCE_OPEN_PALM_MSFT"/> + </enums> + + <!-- XR_FB_face_tracking --> + <enums name="XrFaceExpressionFB" type="enum"> + <enum value="0" name="XR_FACE_EXPRESSION_BROW_LOWERER_L_FB"/> + <enum value="1" name="XR_FACE_EXPRESSION_BROW_LOWERER_R_FB"/> + <enum value="2" name="XR_FACE_EXPRESSION_CHEEK_PUFF_L_FB"/> + <enum value="3" name="XR_FACE_EXPRESSION_CHEEK_PUFF_R_FB"/> + <enum value="4" name="XR_FACE_EXPRESSION_CHEEK_RAISER_L_FB"/> + <enum value="5" name="XR_FACE_EXPRESSION_CHEEK_RAISER_R_FB"/> + <enum value="6" name="XR_FACE_EXPRESSION_CHEEK_SUCK_L_FB"/> + <enum value="7" name="XR_FACE_EXPRESSION_CHEEK_SUCK_R_FB"/> + <enum value="8" name="XR_FACE_EXPRESSION_CHIN_RAISER_B_FB"/> + <enum value="9" name="XR_FACE_EXPRESSION_CHIN_RAISER_T_FB"/> + <enum value="10" name="XR_FACE_EXPRESSION_DIMPLER_L_FB"/> + <enum value="11" name="XR_FACE_EXPRESSION_DIMPLER_R_FB"/> + <enum value="12" name="XR_FACE_EXPRESSION_EYES_CLOSED_L_FB"/> + <enum value="13" name="XR_FACE_EXPRESSION_EYES_CLOSED_R_FB"/> + <enum value="14" name="XR_FACE_EXPRESSION_EYES_LOOK_DOWN_L_FB"/> + <enum value="15" name="XR_FACE_EXPRESSION_EYES_LOOK_DOWN_R_FB"/> + <enum value="16" name="XR_FACE_EXPRESSION_EYES_LOOK_LEFT_L_FB"/> + <enum value="17" name="XR_FACE_EXPRESSION_EYES_LOOK_LEFT_R_FB"/> + <enum value="18" name="XR_FACE_EXPRESSION_EYES_LOOK_RIGHT_L_FB"/> + <enum value="19" name="XR_FACE_EXPRESSION_EYES_LOOK_RIGHT_R_FB"/> + <enum value="20" name="XR_FACE_EXPRESSION_EYES_LOOK_UP_L_FB"/> + <enum value="21" name="XR_FACE_EXPRESSION_EYES_LOOK_UP_R_FB"/> + <enum value="22" name="XR_FACE_EXPRESSION_INNER_BROW_RAISER_L_FB"/> + <enum value="23" name="XR_FACE_EXPRESSION_INNER_BROW_RAISER_R_FB"/> + <enum value="24" name="XR_FACE_EXPRESSION_JAW_DROP_FB"/> + <enum value="25" name="XR_FACE_EXPRESSION_JAW_SIDEWAYS_LEFT_FB"/> + <enum value="26" name="XR_FACE_EXPRESSION_JAW_SIDEWAYS_RIGHT_FB"/> + <enum value="27" name="XR_FACE_EXPRESSION_JAW_THRUST_FB"/> + <enum value="28" name="XR_FACE_EXPRESSION_LID_TIGHTENER_L_FB"/> + <enum value="29" name="XR_FACE_EXPRESSION_LID_TIGHTENER_R_FB"/> + <enum value="30" name="XR_FACE_EXPRESSION_LIP_CORNER_DEPRESSOR_L_FB"/> + <enum value="31" name="XR_FACE_EXPRESSION_LIP_CORNER_DEPRESSOR_R_FB"/> + <enum value="32" name="XR_FACE_EXPRESSION_LIP_CORNER_PULLER_L_FB"/> + <enum value="33" name="XR_FACE_EXPRESSION_LIP_CORNER_PULLER_R_FB"/> + <enum value="34" name="XR_FACE_EXPRESSION_LIP_FUNNELER_LB_FB"/> + <enum value="35" name="XR_FACE_EXPRESSION_LIP_FUNNELER_LT_FB"/> + <enum value="36" name="XR_FACE_EXPRESSION_LIP_FUNNELER_RB_FB"/> + <enum value="37" name="XR_FACE_EXPRESSION_LIP_FUNNELER_RT_FB"/> + <enum value="38" name="XR_FACE_EXPRESSION_LIP_PRESSOR_L_FB"/> + <enum value="39" name="XR_FACE_EXPRESSION_LIP_PRESSOR_R_FB"/> + <enum value="40" name="XR_FACE_EXPRESSION_LIP_PUCKER_L_FB"/> + <enum value="41" name="XR_FACE_EXPRESSION_LIP_PUCKER_R_FB"/> + <enum value="42" name="XR_FACE_EXPRESSION_LIP_STRETCHER_L_FB"/> + <enum value="43" name="XR_FACE_EXPRESSION_LIP_STRETCHER_R_FB"/> + <enum value="44" name="XR_FACE_EXPRESSION_LIP_SUCK_LB_FB"/> + <enum value="45" name="XR_FACE_EXPRESSION_LIP_SUCK_LT_FB"/> + <enum value="46" name="XR_FACE_EXPRESSION_LIP_SUCK_RB_FB"/> + <enum value="47" name="XR_FACE_EXPRESSION_LIP_SUCK_RT_FB"/> + <enum value="48" name="XR_FACE_EXPRESSION_LIP_TIGHTENER_L_FB"/> + <enum value="49" name="XR_FACE_EXPRESSION_LIP_TIGHTENER_R_FB"/> + <enum value="50" name="XR_FACE_EXPRESSION_LIPS_TOWARD_FB"/> + <enum value="51" name="XR_FACE_EXPRESSION_LOWER_LIP_DEPRESSOR_L_FB"/> + <enum value="52" name="XR_FACE_EXPRESSION_LOWER_LIP_DEPRESSOR_R_FB"/> + <enum value="53" name="XR_FACE_EXPRESSION_MOUTH_LEFT_FB"/> + <enum value="54" name="XR_FACE_EXPRESSION_MOUTH_RIGHT_FB"/> + <enum value="55" name="XR_FACE_EXPRESSION_NOSE_WRINKLER_L_FB"/> + <enum value="56" name="XR_FACE_EXPRESSION_NOSE_WRINKLER_R_FB"/> + <enum value="57" name="XR_FACE_EXPRESSION_OUTER_BROW_RAISER_L_FB"/> + <enum value="58" name="XR_FACE_EXPRESSION_OUTER_BROW_RAISER_R_FB"/> + <enum value="59" name="XR_FACE_EXPRESSION_UPPER_LID_RAISER_L_FB"/> + <enum value="60" name="XR_FACE_EXPRESSION_UPPER_LID_RAISER_R_FB"/> + <enum value="61" name="XR_FACE_EXPRESSION_UPPER_LIP_RAISER_L_FB"/> + <enum value="62" name="XR_FACE_EXPRESSION_UPPER_LIP_RAISER_R_FB"/> + <enum value="63" name="XR_FACE_EXPRESSION_COUNT_FB"/> + </enums> + + <enums name="XrFaceExpressionSetFB" type="enum"> + <enum value="0" name="XR_FACE_EXPRESSION_SET_DEFAULT_FB" comment="indicates that the created slink:XrFaceTrackerFB tracks the set of blend shapes described by elink:XrFaceExpressionFB enum, i.e. the flink:xrGetFaceExpressionWeightsFB function returns an array of blend shapes with the count of ename:XR_FACE_EXPRESSION_COUNT_FB and can: be indexed using elink:XrFaceExpressionFB."/> + </enums> + <enums name="XrFaceConfidenceFB" type="enum"> + <enum value="0" name="XR_FACE_CONFIDENCE_LOWER_FACE_FB"/> + <enum value="1" name="XR_FACE_CONFIDENCE_UPPER_FACE_FB"/> + <enum value="2" name="XR_FACE_CONFIDENCE_COUNT_FB"/> + </enums> + + <!-- XR_FB_face_tracking2 --> + <enums name="XrFaceExpression2FB" type="enum"> + <enum value="0" name="XR_FACE_EXPRESSION2_BROW_LOWERER_L_FB"/> + <enum value="1" name="XR_FACE_EXPRESSION2_BROW_LOWERER_R_FB"/> + <enum value="2" name="XR_FACE_EXPRESSION2_CHEEK_PUFF_L_FB"/> + <enum value="3" name="XR_FACE_EXPRESSION2_CHEEK_PUFF_R_FB"/> + <enum value="4" name="XR_FACE_EXPRESSION2_CHEEK_RAISER_L_FB"/> + <enum value="5" name="XR_FACE_EXPRESSION2_CHEEK_RAISER_R_FB"/> + <enum value="6" name="XR_FACE_EXPRESSION2_CHEEK_SUCK_L_FB"/> + <enum value="7" name="XR_FACE_EXPRESSION2_CHEEK_SUCK_R_FB"/> + <enum value="8" name="XR_FACE_EXPRESSION2_CHIN_RAISER_B_FB"/> + <enum value="9" name="XR_FACE_EXPRESSION2_CHIN_RAISER_T_FB"/> + <enum value="10" name="XR_FACE_EXPRESSION2_DIMPLER_L_FB"/> + <enum value="11" name="XR_FACE_EXPRESSION2_DIMPLER_R_FB"/> + <enum value="12" name="XR_FACE_EXPRESSION2_EYES_CLOSED_L_FB"/> + <enum value="13" name="XR_FACE_EXPRESSION2_EYES_CLOSED_R_FB"/> + <enum value="14" name="XR_FACE_EXPRESSION2_EYES_LOOK_DOWN_L_FB"/> + <enum value="15" name="XR_FACE_EXPRESSION2_EYES_LOOK_DOWN_R_FB"/> + <enum value="16" name="XR_FACE_EXPRESSION2_EYES_LOOK_LEFT_L_FB"/> + <enum value="17" name="XR_FACE_EXPRESSION2_EYES_LOOK_LEFT_R_FB"/> + <enum value="18" name="XR_FACE_EXPRESSION2_EYES_LOOK_RIGHT_L_FB"/> + <enum value="19" name="XR_FACE_EXPRESSION2_EYES_LOOK_RIGHT_R_FB"/> + <enum value="20" name="XR_FACE_EXPRESSION2_EYES_LOOK_UP_L_FB"/> + <enum value="21" name="XR_FACE_EXPRESSION2_EYES_LOOK_UP_R_FB"/> + <enum value="22" name="XR_FACE_EXPRESSION2_INNER_BROW_RAISER_L_FB"/> + <enum value="23" name="XR_FACE_EXPRESSION2_INNER_BROW_RAISER_R_FB"/> + <enum value="24" name="XR_FACE_EXPRESSION2_JAW_DROP_FB"/> + <enum value="25" name="XR_FACE_EXPRESSION2_JAW_SIDEWAYS_LEFT_FB"/> + <enum value="26" name="XR_FACE_EXPRESSION2_JAW_SIDEWAYS_RIGHT_FB"/> + <enum value="27" name="XR_FACE_EXPRESSION2_JAW_THRUST_FB"/> + <enum value="28" name="XR_FACE_EXPRESSION2_LID_TIGHTENER_L_FB"/> + <enum value="29" name="XR_FACE_EXPRESSION2_LID_TIGHTENER_R_FB"/> + <enum value="30" name="XR_FACE_EXPRESSION2_LIP_CORNER_DEPRESSOR_L_FB"/> + <enum value="31" name="XR_FACE_EXPRESSION2_LIP_CORNER_DEPRESSOR_R_FB"/> + <enum value="32" name="XR_FACE_EXPRESSION2_LIP_CORNER_PULLER_L_FB"/> + <enum value="33" name="XR_FACE_EXPRESSION2_LIP_CORNER_PULLER_R_FB"/> + <enum value="34" name="XR_FACE_EXPRESSION2_LIP_FUNNELER_LB_FB"/> + <enum value="35" name="XR_FACE_EXPRESSION2_LIP_FUNNELER_LT_FB"/> + <enum value="36" name="XR_FACE_EXPRESSION2_LIP_FUNNELER_RB_FB"/> + <enum value="37" name="XR_FACE_EXPRESSION2_LIP_FUNNELER_RT_FB"/> + <enum value="38" name="XR_FACE_EXPRESSION2_LIP_PRESSOR_L_FB"/> + <enum value="39" name="XR_FACE_EXPRESSION2_LIP_PRESSOR_R_FB"/> + <enum value="40" name="XR_FACE_EXPRESSION2_LIP_PUCKER_L_FB"/> + <enum value="41" name="XR_FACE_EXPRESSION2_LIP_PUCKER_R_FB"/> + <enum value="42" name="XR_FACE_EXPRESSION2_LIP_STRETCHER_L_FB"/> + <enum value="43" name="XR_FACE_EXPRESSION2_LIP_STRETCHER_R_FB"/> + <enum value="44" name="XR_FACE_EXPRESSION2_LIP_SUCK_LB_FB"/> + <enum value="45" name="XR_FACE_EXPRESSION2_LIP_SUCK_LT_FB"/> + <enum value="46" name="XR_FACE_EXPRESSION2_LIP_SUCK_RB_FB"/> + <enum value="47" name="XR_FACE_EXPRESSION2_LIP_SUCK_RT_FB"/> + <enum value="48" name="XR_FACE_EXPRESSION2_LIP_TIGHTENER_L_FB"/> + <enum value="49" name="XR_FACE_EXPRESSION2_LIP_TIGHTENER_R_FB"/> + <enum value="50" name="XR_FACE_EXPRESSION2_LIPS_TOWARD_FB"/> + <enum value="51" name="XR_FACE_EXPRESSION2_LOWER_LIP_DEPRESSOR_L_FB"/> + <enum value="52" name="XR_FACE_EXPRESSION2_LOWER_LIP_DEPRESSOR_R_FB"/> + <enum value="53" name="XR_FACE_EXPRESSION2_MOUTH_LEFT_FB"/> + <enum value="54" name="XR_FACE_EXPRESSION2_MOUTH_RIGHT_FB"/> + <enum value="55" name="XR_FACE_EXPRESSION2_NOSE_WRINKLER_L_FB"/> + <enum value="56" name="XR_FACE_EXPRESSION2_NOSE_WRINKLER_R_FB"/> + <enum value="57" name="XR_FACE_EXPRESSION2_OUTER_BROW_RAISER_L_FB"/> + <enum value="58" name="XR_FACE_EXPRESSION2_OUTER_BROW_RAISER_R_FB"/> + <enum value="59" name="XR_FACE_EXPRESSION2_UPPER_LID_RAISER_L_FB"/> + <enum value="60" name="XR_FACE_EXPRESSION2_UPPER_LID_RAISER_R_FB"/> + <enum value="61" name="XR_FACE_EXPRESSION2_UPPER_LIP_RAISER_L_FB"/> + <enum value="62" name="XR_FACE_EXPRESSION2_UPPER_LIP_RAISER_R_FB"/> + <enum value="63" name="XR_FACE_EXPRESSION2_TONGUE_TIP_INTERDENTAL_FB"/> + <enum value="64" name="XR_FACE_EXPRESSION2_TONGUE_TIP_ALVEOLAR_FB"/> + <enum value="65" name="XR_FACE_EXPRESSION2_TONGUE_FRONT_DORSAL_PALATE_FB"/> + <enum value="66" name="XR_FACE_EXPRESSION2_TONGUE_MID_DORSAL_PALATE_FB"/> + <enum value="67" name="XR_FACE_EXPRESSION2_TONGUE_BACK_DORSAL_VELAR_FB"/> + <enum value="68" name="XR_FACE_EXPRESSION2_TONGUE_OUT_FB"/> + <enum value="69" name="XR_FACE_EXPRESSION2_TONGUE_RETREAT_FB"/> + <enum value="70" name="XR_FACE_EXPRESSION2_COUNT_FB"/> + </enums> + + <enums name="XrFaceExpressionSet2FB" type="enum"> + <enum value="0" name="XR_FACE_EXPRESSION_SET2_DEFAULT_FB" comment="indicates that the created slink:XrFaceTracker2FB tracks the set of blend shapes described by elink:XrFaceExpression2FB enum, i.e. the flink:xrGetFaceExpressionWeights2FB function returns an array of blend shapes with the count of ename:XR_FACE_EXPRESSION2_COUNT_FB and can: be indexed using elink:XrFaceExpression2FB."/> + </enums> + <enums name="XrFaceTrackingDataSource2FB" type="enum"> + <enum value="0" name="XR_FACE_TRACKING_DATA_SOURCE2_VISUAL_FB" comment="face tracking uses visual data to estimate expressions. Face tracking may use audio to further improve the quality of face tracking."/> + <enum value="1" name="XR_FACE_TRACKING_DATA_SOURCE2_AUDIO_FB" comment="face tracking uses audio data to estimate expressions."/> + </enums> + <enums name="XrFaceConfidence2FB" type="enum"> + <enum value="0" name="XR_FACE_CONFIDENCE2_LOWER_FACE_FB"/> + <enum value="1" name="XR_FACE_CONFIDENCE2_UPPER_FACE_FB"/> + <enum value="2" name="XR_FACE_CONFIDENCE2_COUNT_FB"/> + </enums> + + <!-- XR_META_face_tracking_visemes --> + <enums name="XrFaceTrackingVisemeMETA" type="enum"> + <enum value="0" name="XR_FACE_TRACKING_VISEME_SIL_META"/> + <enum value="1" name="XR_FACE_TRACKING_VISEME_PP_META"/> + <enum value="2" name="XR_FACE_TRACKING_VISEME_FF_META"/> + <enum value="3" name="XR_FACE_TRACKING_VISEME_TH_META"/> + <enum value="4" name="XR_FACE_TRACKING_VISEME_DD_META"/> + <enum value="5" name="XR_FACE_TRACKING_VISEME_KK_META"/> + <enum value="6" name="XR_FACE_TRACKING_VISEME_CH_META"/> + <enum value="7" name="XR_FACE_TRACKING_VISEME_SS_META"/> + <enum value="8" name="XR_FACE_TRACKING_VISEME_NN_META"/> + <enum value="9" name="XR_FACE_TRACKING_VISEME_RR_META"/> + <enum value="10" name="XR_FACE_TRACKING_VISEME_AA_META"/> + <enum value="11" name="XR_FACE_TRACKING_VISEME_E_META"/> + <enum value="12" name="XR_FACE_TRACKING_VISEME_IH_META"/> + <enum value="13" name="XR_FACE_TRACKING_VISEME_OH_META"/> + <enum value="14" name="XR_FACE_TRACKING_VISEME_OU_META"/> + </enums> + + <!-- XR_FB_body_tracking --> + <enums name="XrBodyJointFB" type="enum"> + <enum value="0" name="XR_BODY_JOINT_ROOT_FB"/> + <enum value="1" name="XR_BODY_JOINT_HIPS_FB"/> + <enum value="2" name="XR_BODY_JOINT_SPINE_LOWER_FB"/> + <enum value="3" name="XR_BODY_JOINT_SPINE_MIDDLE_FB"/> + <enum value="4" name="XR_BODY_JOINT_SPINE_UPPER_FB"/> + <enum value="5" name="XR_BODY_JOINT_CHEST_FB"/> + <enum value="6" name="XR_BODY_JOINT_NECK_FB"/> + <enum value="7" name="XR_BODY_JOINT_HEAD_FB"/> + <enum value="8" name="XR_BODY_JOINT_LEFT_SHOULDER_FB"/> + <enum value="9" name="XR_BODY_JOINT_LEFT_SCAPULA_FB"/> + <enum value="10" name="XR_BODY_JOINT_LEFT_ARM_UPPER_FB"/> + <enum value="11" name="XR_BODY_JOINT_LEFT_ARM_LOWER_FB"/> + <enum value="12" name="XR_BODY_JOINT_LEFT_HAND_WRIST_TWIST_FB"/> + <enum value="13" name="XR_BODY_JOINT_RIGHT_SHOULDER_FB"/> + <enum value="14" name="XR_BODY_JOINT_RIGHT_SCAPULA_FB"/> + <enum value="15" name="XR_BODY_JOINT_RIGHT_ARM_UPPER_FB"/> + <enum value="16" name="XR_BODY_JOINT_RIGHT_ARM_LOWER_FB"/> + <enum value="17" name="XR_BODY_JOINT_RIGHT_HAND_WRIST_TWIST_FB"/> + <enum value="18" name="XR_BODY_JOINT_LEFT_HAND_PALM_FB"/> + <enum value="19" name="XR_BODY_JOINT_LEFT_HAND_WRIST_FB"/> + <enum value="20" name="XR_BODY_JOINT_LEFT_HAND_THUMB_METACARPAL_FB"/> + <enum value="21" name="XR_BODY_JOINT_LEFT_HAND_THUMB_PROXIMAL_FB"/> + <enum value="22" name="XR_BODY_JOINT_LEFT_HAND_THUMB_DISTAL_FB"/> + <enum value="23" name="XR_BODY_JOINT_LEFT_HAND_THUMB_TIP_FB"/> + <enum value="24" name="XR_BODY_JOINT_LEFT_HAND_INDEX_METACARPAL_FB"/> + <enum value="25" name="XR_BODY_JOINT_LEFT_HAND_INDEX_PROXIMAL_FB"/> + <enum value="26" name="XR_BODY_JOINT_LEFT_HAND_INDEX_INTERMEDIATE_FB"/> + <enum value="27" name="XR_BODY_JOINT_LEFT_HAND_INDEX_DISTAL_FB"/> + <enum value="28" name="XR_BODY_JOINT_LEFT_HAND_INDEX_TIP_FB"/> + <enum value="29" name="XR_BODY_JOINT_LEFT_HAND_MIDDLE_METACARPAL_FB"/> + <enum value="30" name="XR_BODY_JOINT_LEFT_HAND_MIDDLE_PROXIMAL_FB"/> + <enum value="31" name="XR_BODY_JOINT_LEFT_HAND_MIDDLE_INTERMEDIATE_FB"/> + <enum value="32" name="XR_BODY_JOINT_LEFT_HAND_MIDDLE_DISTAL_FB"/> + <enum value="33" name="XR_BODY_JOINT_LEFT_HAND_MIDDLE_TIP_FB"/> + <enum value="34" name="XR_BODY_JOINT_LEFT_HAND_RING_METACARPAL_FB"/> + <enum value="35" name="XR_BODY_JOINT_LEFT_HAND_RING_PROXIMAL_FB"/> + <enum value="36" name="XR_BODY_JOINT_LEFT_HAND_RING_INTERMEDIATE_FB"/> + <enum value="37" name="XR_BODY_JOINT_LEFT_HAND_RING_DISTAL_FB"/> + <enum value="38" name="XR_BODY_JOINT_LEFT_HAND_RING_TIP_FB"/> + <enum value="39" name="XR_BODY_JOINT_LEFT_HAND_LITTLE_METACARPAL_FB"/> + <enum value="40" name="XR_BODY_JOINT_LEFT_HAND_LITTLE_PROXIMAL_FB"/> + <enum value="41" name="XR_BODY_JOINT_LEFT_HAND_LITTLE_INTERMEDIATE_FB"/> + <enum value="42" name="XR_BODY_JOINT_LEFT_HAND_LITTLE_DISTAL_FB"/> + <enum value="43" name="XR_BODY_JOINT_LEFT_HAND_LITTLE_TIP_FB"/> + <enum value="44" name="XR_BODY_JOINT_RIGHT_HAND_PALM_FB"/> + <enum value="45" name="XR_BODY_JOINT_RIGHT_HAND_WRIST_FB"/> + <enum value="46" name="XR_BODY_JOINT_RIGHT_HAND_THUMB_METACARPAL_FB"/> + <enum value="47" name="XR_BODY_JOINT_RIGHT_HAND_THUMB_PROXIMAL_FB"/> + <enum value="48" name="XR_BODY_JOINT_RIGHT_HAND_THUMB_DISTAL_FB"/> + <enum value="49" name="XR_BODY_JOINT_RIGHT_HAND_THUMB_TIP_FB"/> + <enum value="50" name="XR_BODY_JOINT_RIGHT_HAND_INDEX_METACARPAL_FB"/> + <enum value="51" name="XR_BODY_JOINT_RIGHT_HAND_INDEX_PROXIMAL_FB"/> + <enum value="52" name="XR_BODY_JOINT_RIGHT_HAND_INDEX_INTERMEDIATE_FB"/> + <enum value="53" name="XR_BODY_JOINT_RIGHT_HAND_INDEX_DISTAL_FB"/> + <enum value="54" name="XR_BODY_JOINT_RIGHT_HAND_INDEX_TIP_FB"/> + <enum value="55" name="XR_BODY_JOINT_RIGHT_HAND_MIDDLE_METACARPAL_FB"/> + <enum value="56" name="XR_BODY_JOINT_RIGHT_HAND_MIDDLE_PROXIMAL_FB"/> + <enum value="57" name="XR_BODY_JOINT_RIGHT_HAND_MIDDLE_INTERMEDIATE_FB"/> + <enum value="58" name="XR_BODY_JOINT_RIGHT_HAND_MIDDLE_DISTAL_FB"/> + <enum value="59" name="XR_BODY_JOINT_RIGHT_HAND_MIDDLE_TIP_FB"/> + <enum value="60" name="XR_BODY_JOINT_RIGHT_HAND_RING_METACARPAL_FB"/> + <enum value="61" name="XR_BODY_JOINT_RIGHT_HAND_RING_PROXIMAL_FB"/> + <enum value="62" name="XR_BODY_JOINT_RIGHT_HAND_RING_INTERMEDIATE_FB"/> + <enum value="63" name="XR_BODY_JOINT_RIGHT_HAND_RING_DISTAL_FB"/> + <enum value="64" name="XR_BODY_JOINT_RIGHT_HAND_RING_TIP_FB"/> + <enum value="65" name="XR_BODY_JOINT_RIGHT_HAND_LITTLE_METACARPAL_FB"/> + <enum value="66" name="XR_BODY_JOINT_RIGHT_HAND_LITTLE_PROXIMAL_FB"/> + <enum value="67" name="XR_BODY_JOINT_RIGHT_HAND_LITTLE_INTERMEDIATE_FB"/> + <enum value="68" name="XR_BODY_JOINT_RIGHT_HAND_LITTLE_DISTAL_FB"/> + <enum value="69" name="XR_BODY_JOINT_RIGHT_HAND_LITTLE_TIP_FB"/> + <enum value="70" name="XR_BODY_JOINT_COUNT_FB"/> + <enum value="-1" name="XR_BODY_JOINT_NONE_FB"/> + </enums> + + <enums name="XrBodyJointSetFB" type="enum" comment="Describes the set of body joints to track when creating an slink:XrBodyTrackerFB."> + <enum value="0" name="XR_BODY_JOINT_SET_DEFAULT_FB" comment="Indicates that the created slink:XrBodyTrackerFB tracks the set of body joints described by elink:XrBodyJointFB enum, i.e. the flink:xrLocateBodyJointsFB function returns an array of joint locations with the count of ename:XR_BODY_JOINT_COUNT_FB and can be indexed using elink:XrBodyJointFB. This includes the upper body, both hands, and torso."/> + </enums> + + <!-- XR_META_body_tracking_full_body --> + <enums name="XrFullBodyJointMETA" type="enum"> + <enum value="0" name="XR_FULL_BODY_JOINT_ROOT_META"/> + <enum value="1" name="XR_FULL_BODY_JOINT_HIPS_META"/> + <enum value="2" name="XR_FULL_BODY_JOINT_SPINE_LOWER_META"/> + <enum value="3" name="XR_FULL_BODY_JOINT_SPINE_MIDDLE_META"/> + <enum value="4" name="XR_FULL_BODY_JOINT_SPINE_UPPER_META"/> + <enum value="5" name="XR_FULL_BODY_JOINT_CHEST_META"/> + <enum value="6" name="XR_FULL_BODY_JOINT_NECK_META"/> + <enum value="7" name="XR_FULL_BODY_JOINT_HEAD_META"/> + <enum value="8" name="XR_FULL_BODY_JOINT_LEFT_SHOULDER_META"/> + <enum value="9" name="XR_FULL_BODY_JOINT_LEFT_SCAPULA_META"/> + <enum value="10" name="XR_FULL_BODY_JOINT_LEFT_ARM_UPPER_META"/> + <enum value="11" name="XR_FULL_BODY_JOINT_LEFT_ARM_LOWER_META"/> + <enum value="12" name="XR_FULL_BODY_JOINT_LEFT_HAND_WRIST_TWIST_META"/> + <enum value="13" name="XR_FULL_BODY_JOINT_RIGHT_SHOULDER_META"/> + <enum value="14" name="XR_FULL_BODY_JOINT_RIGHT_SCAPULA_META"/> + <enum value="15" name="XR_FULL_BODY_JOINT_RIGHT_ARM_UPPER_META"/> + <enum value="16" name="XR_FULL_BODY_JOINT_RIGHT_ARM_LOWER_META"/> + <enum value="17" name="XR_FULL_BODY_JOINT_RIGHT_HAND_WRIST_TWIST_META"/> + <enum value="18" name="XR_FULL_BODY_JOINT_LEFT_HAND_PALM_META"/> + <enum value="19" name="XR_FULL_BODY_JOINT_LEFT_HAND_WRIST_META"/> + <enum value="20" name="XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_METACARPAL_META"/> + <enum value="21" name="XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_PROXIMAL_META"/> + <enum value="22" name="XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_DISTAL_META"/> + <enum value="23" name="XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_TIP_META"/> + <enum value="24" name="XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_METACARPAL_META"/> + <enum value="25" name="XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_PROXIMAL_META"/> + <enum value="26" name="XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_INTERMEDIATE_META"/> + <enum value="27" name="XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_DISTAL_META"/> + <enum value="28" name="XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_TIP_META"/> + <enum value="29" name="XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_METACARPAL_META"/> + <enum value="30" name="XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_PROXIMAL_META"/> + <enum value="31" name="XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_INTERMEDIATE_META"/> + <enum value="32" name="XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_DISTAL_META"/> + <enum value="33" name="XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_TIP_META"/> + <enum value="34" name="XR_FULL_BODY_JOINT_LEFT_HAND_RING_METACARPAL_META"/> + <enum value="35" name="XR_FULL_BODY_JOINT_LEFT_HAND_RING_PROXIMAL_META"/> + <enum value="36" name="XR_FULL_BODY_JOINT_LEFT_HAND_RING_INTERMEDIATE_META"/> + <enum value="37" name="XR_FULL_BODY_JOINT_LEFT_HAND_RING_DISTAL_META"/> + <enum value="38" name="XR_FULL_BODY_JOINT_LEFT_HAND_RING_TIP_META"/> + <enum value="39" name="XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_METACARPAL_META"/> + <enum value="40" name="XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_PROXIMAL_META"/> + <enum value="41" name="XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_INTERMEDIATE_META"/> + <enum value="42" name="XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_DISTAL_META"/> + <enum value="43" name="XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_TIP_META"/> + <enum value="44" name="XR_FULL_BODY_JOINT_RIGHT_HAND_PALM_META"/> + <enum value="45" name="XR_FULL_BODY_JOINT_RIGHT_HAND_WRIST_META"/> + <enum value="46" name="XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_METACARPAL_META"/> + <enum value="47" name="XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_PROXIMAL_META"/> + <enum value="48" name="XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_DISTAL_META"/> + <enum value="49" name="XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_TIP_META"/> + <enum value="50" name="XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_METACARPAL_META"/> + <enum value="51" name="XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_PROXIMAL_META"/> + <enum value="52" name="XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_INTERMEDIATE_META"/> + <enum value="53" name="XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_DISTAL_META"/> + <enum value="54" name="XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_TIP_META"/> + <enum value="55" name="XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_METACARPAL_META"/> + <enum value="56" name="XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_PROXIMAL_META"/> + <enum value="57" name="XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_INTERMEDIATE_META"/> + <enum value="58" name="XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_DISTAL_META"/> + <enum value="59" name="XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_TIP_META"/> + <enum value="60" name="XR_FULL_BODY_JOINT_RIGHT_HAND_RING_METACARPAL_META"/> + <enum value="61" name="XR_FULL_BODY_JOINT_RIGHT_HAND_RING_PROXIMAL_META"/> + <enum value="62" name="XR_FULL_BODY_JOINT_RIGHT_HAND_RING_INTERMEDIATE_META"/> + <enum value="63" name="XR_FULL_BODY_JOINT_RIGHT_HAND_RING_DISTAL_META"/> + <enum value="64" name="XR_FULL_BODY_JOINT_RIGHT_HAND_RING_TIP_META"/> + <enum value="65" name="XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_METACARPAL_META"/> + <enum value="66" name="XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_PROXIMAL_META"/> + <enum value="67" name="XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_INTERMEDIATE_META"/> + <enum value="68" name="XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_DISTAL_META"/> + <enum value="69" name="XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_TIP_META"/> + <enum value="70" name="XR_FULL_BODY_JOINT_LEFT_UPPER_LEG_META"/> + <enum value="71" name="XR_FULL_BODY_JOINT_LEFT_LOWER_LEG_META"/> + <enum value="72" name="XR_FULL_BODY_JOINT_LEFT_FOOT_ANKLE_TWIST_META"/> + <enum value="73" name="XR_FULL_BODY_JOINT_LEFT_FOOT_ANKLE_META"/> + <enum value="74" name="XR_FULL_BODY_JOINT_LEFT_FOOT_SUBTALAR_META"/> + <enum value="75" name="XR_FULL_BODY_JOINT_LEFT_FOOT_TRANSVERSE_META"/> + <enum value="76" name="XR_FULL_BODY_JOINT_LEFT_FOOT_BALL_META"/> + <enum value="77" name="XR_FULL_BODY_JOINT_RIGHT_UPPER_LEG_META"/> + <enum value="78" name="XR_FULL_BODY_JOINT_RIGHT_LOWER_LEG_META"/> + <enum value="79" name="XR_FULL_BODY_JOINT_RIGHT_FOOT_ANKLE_TWIST_META"/> + <enum value="80" name="XR_FULL_BODY_JOINT_RIGHT_FOOT_ANKLE_META"/> + <enum value="81" name="XR_FULL_BODY_JOINT_RIGHT_FOOT_SUBTALAR_META"/> + <enum value="82" name="XR_FULL_BODY_JOINT_RIGHT_FOOT_TRANSVERSE_META"/> + <enum value="83" name="XR_FULL_BODY_JOINT_RIGHT_FOOT_BALL_META"/> + <enum value="84" name="XR_FULL_BODY_JOINT_COUNT_META"/> + + <!-- used as a sentinel value for root-parent joint --> + <enum value="85" name="XR_FULL_BODY_JOINT_NONE_META"/> + </enums> + + <!-- XR_META_body_tracking_calibration --> + <enums name="XrBodyTrackingCalibrationStateMETA" type="enum"> + <enum value="1" name="XR_BODY_TRACKING_CALIBRATION_STATE_VALID_META" comment="Valid calibration, body tracking expected to be stable."/> + <enum value="2" name="XR_BODY_TRACKING_CALIBRATION_STATE_CALIBRATING_META" comment="Calibration is in progress, body joint poses from ename:XR_FB_body_tracking are valid to read and internally consistent within a single call, but may: be more variable than normal, shifting dramatically before calibration ends."/> + <enum value="3" name="XR_BODY_TRACKING_CALIBRATION_STATE_INVALID_META" comment="Calibration is invalid, accessing the body joint poses from ename:XR_FB_body_tracking is defined behavior but their contents are unspecified. Tracking data may: be read but must: not be interpreted as body tracking poses."/> + </enums> + + <!-- XR_META_body_tracking_fidelity --> + <enums name="XrBodyTrackingFidelityMETA" type="enum"> + <enum value="1" name="XR_BODY_TRACKING_FIDELITY_LOW_META" comment="This value indicates that the body tracking runtime uses a simpler algorithm or less input to estimate the body pose in a way that trades off pose quality for system performance. For example, low fidelity may not accurately track a user's elbows."/> + <enum value="2" name="XR_BODY_TRACKING_FIDELITY_HIGH_META" comment="This value indicates that the body tracking runtime uses more advanced algorithms or more inputs to estimate the body pose. For example high fidelity may track a user's elbows."/> + </enums> + + <!-- XR_FB_eye_tracking_social --> + <enums name="XrEyePositionFB" type="enum"> + <enum value="0" name="XR_EYE_POSITION_LEFT_FB" comment="Specifies the position of the left eye."/> + <enum value="1" name="XR_EYE_POSITION_RIGHT_FB" comment="Specifies the position of the right eye."/> + <enum value="2" name="XR_EYE_POSITION_COUNT_FB" comment="Specifies the number of eyes tracked."/> + </enums> + + <!-- XR_FB_color_space --> + <enums name="XrColorSpaceFB" type="enum"> + <enum value="0" name="XR_COLOR_SPACE_UNMANAGED_FB"/> + <enum value="1" name="XR_COLOR_SPACE_REC2020_FB"/> + <enum value="2" name="XR_COLOR_SPACE_REC709_FB"/> + <enum value="3" name="XR_COLOR_SPACE_RIFT_CV1_FB"/> + <enum value="4" name="XR_COLOR_SPACE_RIFT_S_FB"/> + <enum value="5" name="XR_COLOR_SPACE_QUEST_FB"/> + <enum value="6" name="XR_COLOR_SPACE_P3_FB"/> + <enum value="7" name="XR_COLOR_SPACE_ADOBE_RGB_FB"/> + </enums> + + <!-- XR_FB_composition_layer_alpha_blend --> + <enums name="XrBlendFactorFB" type="enum"> + <enum value="0" name="XR_BLEND_FACTOR_ZERO_FB"/> + <enum value="1" name="XR_BLEND_FACTOR_ONE_FB"/> + <enum value="2" name="XR_BLEND_FACTOR_SRC_ALPHA_FB"/> + <enum value="3" name="XR_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA_FB"/> + <enum value="4" name="XR_BLEND_FACTOR_DST_ALPHA_FB"/> + <enum value="5" name="XR_BLEND_FACTOR_ONE_MINUS_DST_ALPHA_FB"/> + </enums> + + <!-- XR_MSFT_composition_layer_reprojection --> + <enums name="XrReprojectionModeMSFT" type="enum"> + <enum value="1" name="XR_REPROJECTION_MODE_DEPTH_MSFT"/> + <enum value="2" name="XR_REPROJECTION_MODE_PLANAR_FROM_DEPTH_MSFT"/> + <enum value="3" name="XR_REPROJECTION_MODE_PLANAR_MANUAL_MSFT"/> + <enum value="4" name="XR_REPROJECTION_MODE_ORIENTATION_ONLY_MSFT"/> + </enums> + + <!-- XR_BD_body_tracking --> + <enums name="XrBodyJointBD" type="enum"> + <enum value="0" name="XR_BODY_JOINT_PELVIS_BD"/> + <enum value="1" name="XR_BODY_JOINT_LEFT_HIP_BD"/> + <enum value="2" name="XR_BODY_JOINT_RIGHT_HIP_BD"/> + <enum value="3" name="XR_BODY_JOINT_SPINE1_BD"/> + <enum value="4" name="XR_BODY_JOINT_LEFT_KNEE_BD"/> + <enum value="5" name="XR_BODY_JOINT_RIGHT_KNEE_BD"/> + <enum value="6" name="XR_BODY_JOINT_SPINE2_BD"/> + <enum value="7" name="XR_BODY_JOINT_LEFT_ANKLE_BD"/> + <enum value="8" name="XR_BODY_JOINT_RIGHT_ANKLE_BD"/> + <enum value="9" name="XR_BODY_JOINT_SPINE3_BD"/> + <enum value="10" name="XR_BODY_JOINT_LEFT_FOOT_BD"/> + <enum value="11" name="XR_BODY_JOINT_RIGHT_FOOT_BD"/> + <enum value="12" name="XR_BODY_JOINT_NECK_BD"/> + <enum value="13" name="XR_BODY_JOINT_LEFT_COLLAR_BD"/> + <enum value="14" name="XR_BODY_JOINT_RIGHT_COLLAR_BD"/> + <enum value="15" name="XR_BODY_JOINT_HEAD_BD"/> + <enum value="16" name="XR_BODY_JOINT_LEFT_SHOULDER_BD"/> + <enum value="17" name="XR_BODY_JOINT_RIGHT_SHOULDER_BD"/> + <enum value="18" name="XR_BODY_JOINT_LEFT_ELBOW_BD"/> + <enum value="19" name="XR_BODY_JOINT_RIGHT_ELBOW_BD"/> + <enum value="20" name="XR_BODY_JOINT_LEFT_WRIST_BD"/> + <enum value="21" name="XR_BODY_JOINT_RIGHT_WRIST_BD"/> + <enum value="22" name="XR_BODY_JOINT_LEFT_HAND_BD"/> + <enum value="23" name="XR_BODY_JOINT_RIGHT_HAND_BD"/> + </enums> + + <enums name="XrBodyJointSetBD" type="enum" comment="Describes the set of body joints to track when creating an slink:XrBodyTrackerBD."> + <enum value="1" name="XR_BODY_JOINT_SET_BODY_WITHOUT_ARM_BD" comment="Contains joints in elink:XrBodyJointBD in the range ename:XR_BODY_JOINT_PELVIS_BD through ename:XR_BODY_JOINT_HEAD_BD inclusive, a total of dlink:XR_BODY_JOINT_WITHOUT_ARM_COUNT_BD joints."/> + <enum value="2" name="XR_BODY_JOINT_SET_FULL_BODY_JOINTS_BD" comment="Contains joints in elink:XrBodyJointBD in the range ename:XR_BODY_JOINT_PELVIS_BD through ename:XR_BODY_JOINT_RIGHT_HAND_BD inclusive, a total of dlink:XR_BODY_JOINT_COUNT_BD joints."/> + </enums> + + <!-- XR_BD_body_tracking_auxiliary_metrics --> + <enums name="XrBodyTrackingPostureBD" type="enum"> + <enum value="1" name="XR_BODY_TRACKING_POSTURE_STOMP_BD" comment="Represents a stomp posture."/> + <enum value="2" name="XR_BODY_TRACKING_POSTURE_STATIC_BD" comment="Represents a static posture where the tracked user maintains a fixed pose."/> + </enums> + + <enums name="XrBodyTrackingStatusBD" type="enum"> + <enum value="0" name="XR_BODY_TRACKING_STATUS_INVALID_BD" comment="Body tracking status is invalid"/> + <enum value="1" name="XR_BODY_TRACKING_STATUS_VALID_BD" comment="Body tracking status is valid"/> + <enum value="2" name="XR_BODY_TRACKING_STATUS_LIMITED_BD" comment="Body tracking status is limited"/> + </enums> + + <enums name="XrBodyTrackingMessageBD" type="enum"> + <enum value="0" name="XR_BODY_TRACKING_MESSAGE_NO_ERROR_BD" comment="No error"/> + <enum value="1" name="XR_BODY_TRACKING_MESSAGE_TRACKER_NOT_CALIBRATED_BD" comment="Body tracker is not calibrated"/> + <enum value="2" name="XR_BODY_TRACKING_MESSAGE_TRACKER_NUM_NOT_ENOUGH_BD" comment="The number of connected trackers is insufficient."/> + <enum value="3" name="XR_BODY_TRACKING_MESSAGE_TRACKER_STATE_NOT_SATISFIED_BD" comment="The tracker is not in normal tracking mode, e.g., it is being charged."/> + <enum value="4" name="XR_BODY_TRACKING_MESSAGE_TRACKER_PERSISTENT_INVISIBILITY_BD" comment="The tracker remains persistently undetected or invisible."/> + <enum value="5" name="XR_BODY_TRACKING_MESSAGE_TRACKER_DATA_ERROR_BD" comment="There are errors in the data generated by the tracker."/> + <enum value="6" name="XR_BODY_TRACKING_MESSAGE_USER_CHANGE_BD" comment="The user of the tracker may have been changed."/> + <enum value="7" name="XR_BODY_TRACKING_MESSAGE_TRACKING_POSE_ERROR_BD" comment="The body tracking pose is abnormal, e.g. the head is twisted."/> + </enums> + + <!-- XR_ULTRALEAP_hand_tracking_forearm --> + <enums name="XrHandForearmJointULTRALEAP" type="enum"> + <enum value="0" name="XR_HAND_FOREARM_JOINT_PALM_ULTRALEAP"/> + <enum value="1" name="XR_HAND_FOREARM_JOINT_WRIST_ULTRALEAP"/> + <enum value="2" name="XR_HAND_FOREARM_JOINT_THUMB_METACARPAL_ULTRALEAP"/> + <enum value="3" name="XR_HAND_FOREARM_JOINT_THUMB_PROXIMAL_ULTRALEAP"/> + <enum value="4" name="XR_HAND_FOREARM_JOINT_THUMB_DISTAL_ULTRALEAP"/> + <enum value="5" name="XR_HAND_FOREARM_JOINT_THUMB_TIP_ULTRALEAP"/> + <enum value="6" name="XR_HAND_FOREARM_JOINT_INDEX_METACARPAL_ULTRALEAP"/> + <enum value="7" name="XR_HAND_FOREARM_JOINT_INDEX_PROXIMAL_ULTRALEAP"/> + <enum value="8" name="XR_HAND_FOREARM_JOINT_INDEX_INTERMEDIATE_ULTRALEAP"/> + <enum value="9" name="XR_HAND_FOREARM_JOINT_INDEX_DISTAL_ULTRALEAP"/> + <enum value="10" name="XR_HAND_FOREARM_JOINT_INDEX_TIP_ULTRALEAP"/> + <enum value="11" name="XR_HAND_FOREARM_JOINT_MIDDLE_METACARPAL_ULTRALEAP"/> + <enum value="12" name="XR_HAND_FOREARM_JOINT_MIDDLE_PROXIMAL_ULTRALEAP"/> + <enum value="13" name="XR_HAND_FOREARM_JOINT_MIDDLE_INTERMEDIATE_ULTRALEAP"/> + <enum value="14" name="XR_HAND_FOREARM_JOINT_MIDDLE_DISTAL_ULTRALEAP"/> + <enum value="15" name="XR_HAND_FOREARM_JOINT_MIDDLE_TIP_ULTRALEAP"/> + <enum value="16" name="XR_HAND_FOREARM_JOINT_RING_METACARPAL_ULTRALEAP"/> + <enum value="17" name="XR_HAND_FOREARM_JOINT_RING_PROXIMAL_ULTRALEAP"/> + <enum value="18" name="XR_HAND_FOREARM_JOINT_RING_INTERMEDIATE_ULTRALEAP"/> + <enum value="19" name="XR_HAND_FOREARM_JOINT_RING_DISTAL_ULTRALEAP"/> + <enum value="20" name="XR_HAND_FOREARM_JOINT_RING_TIP_ULTRALEAP"/> + <enum value="21" name="XR_HAND_FOREARM_JOINT_LITTLE_METACARPAL_ULTRALEAP"/> + <enum value="22" name="XR_HAND_FOREARM_JOINT_LITTLE_PROXIMAL_ULTRALEAP"/> + <enum value="23" name="XR_HAND_FOREARM_JOINT_LITTLE_INTERMEDIATE_ULTRALEAP"/> + <enum value="24" name="XR_HAND_FOREARM_JOINT_LITTLE_DISTAL_ULTRALEAP"/> + <enum value="25" name="XR_HAND_FOREARM_JOINT_LITTLE_TIP_ULTRALEAP"/> + <enum value="26" name="XR_HAND_FOREARM_JOINT_ELBOW_ULTRALEAP"/> + </enums> + + <!-- enums for XR_ML_marker_understanding --> + <enums name="XrMarkerDetectorProfileML" type="enum"> + <enum value="0" name="XR_MARKER_DETECTOR_PROFILE_DEFAULT_ML" comment="Tracker profile that covers standard use cases. If this does not suite the needs of the application try the other profiles listed below."/> + <enum value="1" name="XR_MARKER_DETECTOR_PROFILE_SPEED_ML" comment="Optimized for speed. Use this profile to reduce the compute load and increase detection/tracker speed. This can result in low accuracy poses."/> + <enum value="2" name="XR_MARKER_DETECTOR_PROFILE_ACCURACY_ML" comment="Optimized for accuracy. Use this profile to optimize for accurate marker poses. This can cause increased load on the compute."/> + <enum value="3" name="XR_MARKER_DETECTOR_PROFILE_SMALL_TARGETS_ML" comment="Optimized for small targets. Use this profile to optimize for markers that are small or for larger markers that need to be detected from afar."/> + <enum value="4" name="XR_MARKER_DETECTOR_PROFILE_LARGE_FOV_ML" comment="Optimized for FoV. Use this profile to be able to detect markers across a larger FoV. The marker tracker system will attempt to use multiple cameras to detect the markers."/> + <enum value="5" name="XR_MARKER_DETECTOR_PROFILE_CUSTOM_ML" comment="Custom Tracker Profile. The application can define a custom tracker profile. See slink:XrMarkerDetectorCustomProfileInfoML for more details."/> + </enums> + <enums name="XrMarkerTypeML" type="enum"> + <enum value="0" name="XR_MARKER_TYPE_ARUCO_ML" comment="Aruco Marker detection and localization. The marker id of the Aruco marker is available via flink:xrGetMarkerNumberML."/> + <enum value="1" name="XR_MARKER_TYPE_APRIL_TAG_ML" comment="AprilTag detection and localization. The marker id of the AprilTags is available via flink:xrGetMarkerNumberML."/> + <enum value="2" name="XR_MARKER_TYPE_QR_ML" comment="QR code detection and localization. The contents of the QR code is available via flink:xrGetMarkerStringML."/> + <enum value="3" name="XR_MARKER_TYPE_EAN_13_ML" comment="EAN-13, detection only, not locatable. The contents of the barcode is available via flink:xrGetMarkerStringML."/> + <enum value="4" name="XR_MARKER_TYPE_UPC_A_ML" comment="UPC-A, detection only, not locatable. The contents of the barcode is available via flink:xrGetMarkerStringML."/> + <enum value="5" name="XR_MARKER_TYPE_CODE_128_ML" comment="Code 128, detection only, not locatable. The contents of the barcode is available via flink:xrGetMarkerStringML."/> + </enums> + <enums name="XrMarkerArucoDictML" type="enum"> + <enum value="0" name="XR_MARKER_ARUCO_DICT_4X4_50_ML" comment="4 by 4 pixel Aruco marker dictionary with 50 IDs."/> + <enum value="1" name="XR_MARKER_ARUCO_DICT_4X4_100_ML" comment="4 by 4 pixel Aruco marker dictionary with 100 IDs."/> + <enum value="2" name="XR_MARKER_ARUCO_DICT_4X4_250_ML" comment="4 by 4 pixel Aruco marker dictionary with 250 IDs."/> + <enum value="3" name="XR_MARKER_ARUCO_DICT_4X4_1000_ML" comment="4 by 4 pixel Aruco marker dictionary with 1000 IDs."/> + <enum value="4" name="XR_MARKER_ARUCO_DICT_5X5_50_ML" comment="5 by 5 pixel Aruco marker dictionary with 50 IDs."/> + <enum value="5" name="XR_MARKER_ARUCO_DICT_5X5_100_ML" comment="5 by 5 pixel Aruco marker dictionary with 100 IDs."/> + <enum value="6" name="XR_MARKER_ARUCO_DICT_5X5_250_ML" comment="5 by 5 pixel Aruco marker dictionary with 250 IDs."/> + <enum value="7" name="XR_MARKER_ARUCO_DICT_5X5_1000_ML" comment="5 by 5 pixel Aruco marker dictionary with 1000 IDs."/> + <enum value="8" name="XR_MARKER_ARUCO_DICT_6X6_50_ML" comment="6 by 6 pixel Aruco marker dictionary with 50 IDs."/> + <enum value="9" name="XR_MARKER_ARUCO_DICT_6X6_100_ML" comment="6 by 6 pixel Aruco marker dictionary with 100 IDs."/> + <enum value="10" name="XR_MARKER_ARUCO_DICT_6X6_250_ML" comment="6 by 6 pixel Aruco marker dictionary with 250 IDs."/> + <enum value="11" name="XR_MARKER_ARUCO_DICT_6X6_1000_ML" comment="6 by 6 pixel Aruco marker dictionary with 1000 IDs."/> + <enum value="12" name="XR_MARKER_ARUCO_DICT_7X7_50_ML" comment="7 by 7 pixel Aruco marker dictionary with 50 IDs."/> + <enum value="13" name="XR_MARKER_ARUCO_DICT_7X7_100_ML" comment="7 by 7 pixel Aruco marker dictionary with 100 IDs."/> + <enum value="14" name="XR_MARKER_ARUCO_DICT_7X7_250_ML" comment="7 by 7 pixel Aruco marker dictionary with 250 IDs."/> + <enum value="15" name="XR_MARKER_ARUCO_DICT_7X7_1000_ML" comment="7 by 7 pixel Aruco marker dictionary with 1000 IDs."/> + </enums> + <enums name="XrMarkerAprilTagDictML" type="enum"> + <enum value="0" name="XR_MARKER_APRIL_TAG_DICT_16H5_ML" comment="4 by 4 bits, minimum Hamming distance between any two codes = 5, 30 codes."/> + <enum value="1" name="XR_MARKER_APRIL_TAG_DICT_25H9_ML" comment="5 by 5 bits, minimum Hamming distance between any two codes = 9, 35 codes."/> + <enum value="2" name="XR_MARKER_APRIL_TAG_DICT_36H10_ML" comment="6 by 6 bits, minimum Hamming distance between any two codes = 10, 2320 codes."/> + <enum value="3" name="XR_MARKER_APRIL_TAG_DICT_36H11_ML" comment="6 by 6 bits, minimum Hamming distance between any two codes = 11, 587 codes."/> + </enums> + <enums name="XrMarkerDetectorFpsML" type="enum"> + <enum value="0" name="XR_MARKER_DETECTOR_FPS_LOW_ML" comment="Low FPS."/> + <enum value="1" name="XR_MARKER_DETECTOR_FPS_MEDIUM_ML" comment="Medium FPS."/> + <enum value="2" name="XR_MARKER_DETECTOR_FPS_HIGH_ML" comment="High FPS."/> + <enum value="3" name="XR_MARKER_DETECTOR_FPS_MAX_ML" comment="Max possible FPS."/> + </enums> + <enums name="XrMarkerDetectorResolutionML" type="enum"> + <enum value="0" name="XR_MARKER_DETECTOR_RESOLUTION_LOW_ML" comment="Low Resolution."/> + <enum value="1" name="XR_MARKER_DETECTOR_RESOLUTION_MEDIUM_ML" comment="Medium Resolution."/> + <enum value="2" name="XR_MARKER_DETECTOR_RESOLUTION_HIGH_ML" comment="High Resolution."/> + </enums> + <enums name="XrMarkerDetectorCameraML" type="enum"> + <enum value="0" name="XR_MARKER_DETECTOR_CAMERA_RGB_CAMERA_ML" comment="Single RGB camera."/> + <enum value="1" name="XR_MARKER_DETECTOR_CAMERA_WORLD_CAMERAS_ML" comment="One or more world cameras."/> + </enums> + <enums name="XrMarkerDetectorCornerRefineMethodML" type="enum"> + <enum value="0" name="XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_NONE_ML" comment="No refinement. Inaccurate corners."/> + <enum value="1" name="XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_SUBPIX_ML" comment="Subpixel refinement. Corners have subpixel coordinates. High detection rate, very fast, reasonable accuracy."/> + <enum value="2" name="XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_CONTOUR_ML" comment="Contour refinement. High detection rate, fast, reasonable accuracy."/> + <enum value="3" name="XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_APRIL_TAG_ML" comment="AprilTag refinement. Reasonable detection rate, slowest, but very accurate. Only valid with AprilTags."/> + </enums> + <enums name="XrMarkerDetectorFullAnalysisIntervalML" type="enum"> + <enum value="0" name="XR_MARKER_DETECTOR_FULL_ANALYSIS_INTERVAL_MAX_ML" comment="Detector analyzes every frame fully."/> + <enum value="1" name="XR_MARKER_DETECTOR_FULL_ANALYSIS_INTERVAL_FAST_ML" comment="Detector analyzes frame fully very often."/> + <enum value="2" name="XR_MARKER_DETECTOR_FULL_ANALYSIS_INTERVAL_MEDIUM_ML" comment="Detector analyzes frame fully a few times per second."/> + <enum value="3" name="XR_MARKER_DETECTOR_FULL_ANALYSIS_INTERVAL_SLOW_ML" comment="Detector analyzes frame fully about every second."/> + </enums> + <enums name="XrMarkerDetectorStatusML" type="enum"> + <enum value="0" name="XR_MARKER_DETECTOR_STATUS_PENDING_ML" comment="The marker detector is working on a new snapshot."/> + <enum value="1" name="XR_MARKER_DETECTOR_STATUS_READY_ML" comment="The marker detector is ready to be inspected."/> + <enum value="2" name="XR_MARKER_DETECTOR_STATUS_ERROR_ML" comment="The marker detector has encountered a fatal error."/> + </enums> + + <!-- XR_ANDROID_spatial_object_tracking --> + <enums name="XrSpatialObjectSemanticLabelANDROID" type="enum"> + <enum value="0" name="XR_SPATIAL_OBJECT_SEMANTIC_LABEL_UNCATEGORIZED_ANDROID" comment="The runtime was unable to classify this entity."/> + <enum value="1" name="XR_SPATIAL_OBJECT_SEMANTIC_LABEL_KEYBOARD_ANDROID" comment="The entity is a keyboard."/> + <enum value="2" name="XR_SPATIAL_OBJECT_SEMANTIC_LABEL_MOUSE_ANDROID" comment="The entity is a mouse."/> + <enum value="3" name="XR_SPATIAL_OBJECT_SEMANTIC_LABEL_LAPTOP_BASE_ANDROID" comment="The entity is a laptop."/> + </enums> + + <!-- Flags --> + <enums name="XrInstanceCreateFlagBits" type="bitmask"> + <!-- This is currently empty, awaiting future flags. --> + </enums> + <enums name="XrSessionCreateFlagBits" type="bitmask"> + <!-- This is currently empty, awaiting future flags. --> + </enums> + <enums name="XrSwapchainCreateFlagBits" type="bitmask"> + <enum bitpos="0" name="XR_SWAPCHAIN_CREATE_PROTECTED_CONTENT_BIT" comment="Content will be protected from CPU access"/> + <enum bitpos="1" name="XR_SWAPCHAIN_CREATE_STATIC_IMAGE_BIT" comment="Only one image will be acquired from this swapchain over its lifetime"/> + </enums> + <enums name="XrSwapchainUsageFlagBits" type="bitmask"> + <enum bitpos="0" name="XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT" comment="Specifies that the image may: be a color rendering target."/> + <enum bitpos="1" name="XR_SWAPCHAIN_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" comment="Specifies that the image may: be a depth/stencil rendering target."/> + <enum bitpos="2" name="XR_SWAPCHAIN_USAGE_UNORDERED_ACCESS_BIT" comment="Specifies that the image may: be accessed out of order and that access may: be via atomic operations."/> + <enum bitpos="3" name="XR_SWAPCHAIN_USAGE_TRANSFER_SRC_BIT" comment="Specifies that the image may: be used as the source of a transfer operation."/> + <enum bitpos="4" name="XR_SWAPCHAIN_USAGE_TRANSFER_DST_BIT" comment="Specifies that the image may: be used as the destination of a transfer operation."/> + <enum bitpos="5" name="XR_SWAPCHAIN_USAGE_SAMPLED_BIT" comment="Specifies that the image may: be sampled by a shader."/> + <enum bitpos="6" name="XR_SWAPCHAIN_USAGE_MUTABLE_FORMAT_BIT" comment="Specifies that the image may: be reinterpreted as another image format."/> + </enums> + <enums name="XrViewStateFlagBits" type="bitmask"> + <enum bitpos="0" name="XR_VIEW_STATE_ORIENTATION_VALID_BIT" comment="Indicates validity of all slink:XrView orientations"/> + <enum bitpos="1" name="XR_VIEW_STATE_POSITION_VALID_BIT" comment="Indicates validity of all slink:XrView positions"/> + <enum bitpos="2" name="XR_VIEW_STATE_ORIENTATION_TRACKED_BIT" comment="Indicates whether all slink:XrView orientations are actively tracked"/> + <enum bitpos="3" name="XR_VIEW_STATE_POSITION_TRACKED_BIT" comment="Indicates whether all slink:XrView positions are actively tracked"/> + </enums> + <enums name="XrCompositionLayerFlagBits" type="bitmask"> + <enum bitpos="0" name="XR_COMPOSITION_LAYER_CORRECT_CHROMATIC_ABERRATION_BIT" comment="Enables chromatic aberration correction when not done by default. This flag has no effect on any known conformant runtime, and is officially deprecated in OpenXR 1.1." deprecated="ignored"/> + <enum bitpos="1" name="XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT" comment="Enables the layer texture alpha channel."/> + <enum bitpos="2" name="XR_COMPOSITION_LAYER_UNPREMULTIPLIED_ALPHA_BIT" comment="Indicates the texture color channels have not been premultiplied by the texture alpha channel."/> + </enums> + + <enums name="XrSpaceLocationFlagBits" type="bitmask"> + <enum bitpos="0" name="XR_SPACE_LOCATION_ORIENTATION_VALID_BIT" comment="Indicates that the pname:orientation member contains valid data"/> + <enum bitpos="1" name="XR_SPACE_LOCATION_POSITION_VALID_BIT" comment="Indicates that the pname:position member contains valid data"/> + <enum bitpos="2" name="XR_SPACE_LOCATION_ORIENTATION_TRACKED_BIT" comment="Indicates whether pname:pose member contains an actively tracked pname:orientation"/> + <enum bitpos="3" name="XR_SPACE_LOCATION_POSITION_TRACKED_BIT" comment="Indicates whether pname:pose member contains an actively tracked pname:position"/> + </enums> + <enums name="XrSpaceVelocityFlagBits" type="bitmask"> + <enum bitpos="0" name="XR_SPACE_VELOCITY_LINEAR_VALID_BIT" comment="Indicates that the pname:linearVelocity member contains valid data. Applications must: not read the pname:linearVelocity field if this flag is unset."/> + <enum bitpos="1" name="XR_SPACE_VELOCITY_ANGULAR_VALID_BIT" comment="Indicates that the pname:angularVelocity member contains valid data. Applications must: not read the pname:angularVelocity field if this flag is unset."/> + </enums> + + <enums name="XrInputSourceLocalizedNameFlagBits" type="bitmask"> + <enum bitpos="0" name="XR_INPUT_SOURCE_LOCALIZED_NAME_USER_PATH_BIT" comment="Asks for the part of the string which indicates the top level user path the source represents"/> + <enum bitpos="1" name="XR_INPUT_SOURCE_LOCALIZED_NAME_INTERACTION_PROFILE_BIT" comment="Asks for the part of the string which represents the interaction profile of the source"/> + <enum bitpos="2" name="XR_INPUT_SOURCE_LOCALIZED_NAME_COMPONENT_BIT" comment="Asks for the part of the string which represents the component on the device which needs to be interacted with"/> + </enums> + + <!-- openxr_loader_negotiation.h --> + <enums name="XrLoaderInterfaceStructs" type="enum"> + <enum value="0" name="XR_LOADER_INTERFACE_STRUCT_UNINTIALIZED"/> + <enum value="1" name="XR_LOADER_INTERFACE_STRUCT_LOADER_INFO"/> + <enum value="2" name="XR_LOADER_INTERFACE_STRUCT_API_LAYER_REQUEST"/> + <enum value="3" name="XR_LOADER_INTERFACE_STRUCT_RUNTIME_REQUEST"/> + <enum value="4" name="XR_LOADER_INTERFACE_STRUCT_API_LAYER_CREATE_INFO"/> + <enum value="5" name="XR_LOADER_INTERFACE_STRUCT_API_LAYER_NEXT_INFO"/> + </enums> + + <!-- flags for XR_KHR_vulkan_enable2 --> + <enums name="XrVulkanInstanceCreateFlagBitsKHR" type="bitmask"> + <!-- This is currently empty, awaiting future flags. --> + </enums> + <enums name="XrVulkanDeviceCreateFlagBitsKHR" type="bitmask"> + <!-- This is currently empty, awaiting future flags. --> + </enums> + + <!-- flags for XR_EXT_debug_utils --> + <enums name="XrDebugUtilsMessageSeverityFlagBitsEXT" type="bitmask"> + <enum bitpos="0" name="XR_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT" comment="Most verbose output severity, typically used for debugging."/> + <enum bitpos="4" name="XR_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT" comment="General info message"/> + <enum bitpos="8" name="XR_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT" comment="Indicates the item may be the cause of issues."/> + <enum bitpos="12" name="XR_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT" comment="Indicates that the item is definitely related to erroneous behavior."/> + </enums> + <enums name="XrDebugUtilsMessageTypeFlagBitsEXT" type="bitmask"> + <enum bitpos="0" name="XR_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT" comment="Indicates this is a general message"/> + <enum bitpos="1" name="XR_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT" comment="Indicates the message is related to a validation message"/> + <enum bitpos="2" name="XR_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT" comment="Indicates the message is related to a potential performance situation"/> + <enum bitpos="3" name="XR_DEBUG_UTILS_MESSAGE_TYPE_CONFORMANCE_BIT_EXT" comment="Indicates the message is related to a non-conformant runtime result"/> + </enums> + + <!-- flags for XR_EXTX_overlay --> + <enums name="XrOverlayMainSessionFlagBitsEXTX" type="bitmask"> + <enum bitpos="0" name="XR_OVERLAY_MAIN_SESSION_ENABLED_COMPOSITION_LAYER_INFO_DEPTH_BIT_EXTX" comment="Indicates the main session enabled `XR_KHR_composition_layer_depth`"/> + </enums> + <enums name="XrOverlaySessionCreateFlagBitsEXTX" type="bitmask"> + </enums> + + <!-- enums XR_MSFT_spatial_graph_bridge --> + <enums name="XrSpatialGraphNodeTypeMSFT" type="enum"> + <enum value="1" name="XR_SPATIAL_GRAPH_NODE_TYPE_STATIC_MSFT"/> + <enum value="2" name="XR_SPATIAL_GRAPH_NODE_TYPE_DYNAMIC_MSFT"/> + </enums> + + <!-- enums XR_MSFT_scene_understanding --> + <enums name="XrSceneObjectTypeMSFT" type="enum"> + <enum value="-1" name="XR_SCENE_OBJECT_TYPE_UNCATEGORIZED_MSFT"/> + <enum value="1" name="XR_SCENE_OBJECT_TYPE_BACKGROUND_MSFT"/> + <enum value="2" name="XR_SCENE_OBJECT_TYPE_WALL_MSFT"/> + <enum value="3" name="XR_SCENE_OBJECT_TYPE_FLOOR_MSFT"/> + <enum value="4" name="XR_SCENE_OBJECT_TYPE_CEILING_MSFT"/> + <enum value="5" name="XR_SCENE_OBJECT_TYPE_PLATFORM_MSFT"/> + <enum value="6" name="XR_SCENE_OBJECT_TYPE_INFERRED_MSFT"/> + </enums> + <enums name="XrScenePlaneAlignmentTypeMSFT" type="enum"> + <enum value="0" name="XR_SCENE_PLANE_ALIGNMENT_TYPE_NON_ORTHOGONAL_MSFT"/> + <enum value="1" name="XR_SCENE_PLANE_ALIGNMENT_TYPE_HORIZONTAL_MSFT"/> + <enum value="2" name="XR_SCENE_PLANE_ALIGNMENT_TYPE_VERTICAL_MSFT"/> + </enums> + <enums name="XrSceneComputeStateMSFT" type="enum"> + <enum value="0" name="XR_SCENE_COMPUTE_STATE_NONE_MSFT"/> + <enum value="1" name="XR_SCENE_COMPUTE_STATE_UPDATING_MSFT"/> + <enum value="2" name="XR_SCENE_COMPUTE_STATE_COMPLETED_MSFT"/> + <enum value="3" name="XR_SCENE_COMPUTE_STATE_COMPLETED_WITH_ERROR_MSFT"/> + </enums> + <enums name="XrSceneComponentTypeMSFT" type="enum"> + <enum value="-1" name="XR_SCENE_COMPONENT_TYPE_INVALID_MSFT"/> + <enum value="1" name="XR_SCENE_COMPONENT_TYPE_OBJECT_MSFT"/> + <enum value="2" name="XR_SCENE_COMPONENT_TYPE_PLANE_MSFT"/> + <enum value="3" name="XR_SCENE_COMPONENT_TYPE_VISUAL_MESH_MSFT"/> + <enum value="4" name="XR_SCENE_COMPONENT_TYPE_COLLIDER_MESH_MSFT"/> + </enums> + <enums name="XrSceneComputeFeatureMSFT" type="enum"> + <enum value="1" name="XR_SCENE_COMPUTE_FEATURE_PLANE_MSFT"/> + <enum value="2" name="XR_SCENE_COMPUTE_FEATURE_PLANE_MESH_MSFT"/> + <enum value="3" name="XR_SCENE_COMPUTE_FEATURE_VISUAL_MESH_MSFT"/> + <enum value="4" name="XR_SCENE_COMPUTE_FEATURE_COLLIDER_MESH_MSFT"/> + </enums> + <enums name="XrSceneComputeConsistencyMSFT" type="enum"> + <enum value="1" name="XR_SCENE_COMPUTE_CONSISTENCY_SNAPSHOT_COMPLETE_MSFT"/> + <enum value="2" name="XR_SCENE_COMPUTE_CONSISTENCY_SNAPSHOT_INCOMPLETE_FAST_MSFT"/> + <enum value="3" name="XR_SCENE_COMPUTE_CONSISTENCY_OCCLUSION_OPTIMIZED_MSFT"/> + </enums> + <enums name="XrMeshComputeLodMSFT" type="enum"> + <enum value="1" name="XR_MESH_COMPUTE_LOD_COARSE_MSFT"/> + <enum value="2" name="XR_MESH_COMPUTE_LOD_MEDIUM_MSFT"/> + <enum value="3" name="XR_MESH_COMPUTE_LOD_FINE_MSFT"/> + <enum value="4" name="XR_MESH_COMPUTE_LOD_UNLIMITED_MSFT"/> + </enums> + + <!-- enums for XR_MSFT_scene_marker --> + <enums name="XrSceneMarkerTypeMSFT" type="enum"> + <enum value="1" name="XR_SCENE_MARKER_TYPE_QR_CODE_MSFT"/> + </enums> + <enums name="XrSceneMarkerQRCodeSymbolTypeMSFT" type="enum"> + <enum value="1" name="XR_SCENE_MARKER_QR_CODE_SYMBOL_TYPE_QR_CODE_MSFT"/> + <enum value="2" name="XR_SCENE_MARKER_QR_CODE_SYMBOL_TYPE_MICRO_QR_CODE_MSFT"/> + </enums> + + <!-- flags for XR_FB_android_surface_swapchain_create --> + <enums name="XrAndroidSurfaceSwapchainFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_ANDROID_SURFACE_SWAPCHAIN_SYNCHRONOUS_BIT_FB" comment="Create the underlying BufferQueue in synchronous mode"/> + <enum bitpos="1" name="XR_ANDROID_SURFACE_SWAPCHAIN_USE_TIMESTAMPS_BIT_FB" comment="Acquire most recent buffer whose presentation timestamp is not greater than display time of final composited frame"/> + </enums> + + <!-- flags for XR_FB_composition_layer_image_layout --> + <enums name="XrCompositionLayerImageLayoutFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_COMPOSITION_LAYER_IMAGE_LAYOUT_VERTICAL_FLIP_BIT_FB" comment="The coordinate origin of the swapchain image must be considered to be flipped vertically."/> + </enums> + + <!-- flags for XR_FB_foveation --> + <enums name="XrSwapchainCreateFoveationFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_SWAPCHAIN_CREATE_FOVEATION_SCALED_BIN_BIT_FB" comment="Explicitly create the swapchain with scaled bin foveation support. The application must ensure that the swapchain is using the OpenGL graphics API and that the QCOM_texture_foveated extension is supported and enabled."/> + <enum bitpos="1" name="XR_SWAPCHAIN_CREATE_FOVEATION_FRAGMENT_DENSITY_MAP_BIT_FB" comment="Explicitly create the swapchain with fragment density map foveation support. The application must ensure that the swapchain is using the Vulkan graphics API and that the VK_EXT_fragment_density_map extension is supported and enabled."/> + </enums> + <enums name="XrSwapchainStateFoveationFlagBitsFB" type="bitmask"> + <!-- This is currently empty, awaiting future flags. --> + </enums> + + <!-- flags for XR_META_foveation_eye_tracked --> + <enums name="XrFoveationEyeTrackedProfileCreateFlagBitsMETA" type="bitmask"> + <!-- This is currently empty, awaiting future flags. --> + </enums> + <enums name="XrFoveationEyeTrackedStateFlagBitsMETA" type="bitmask"> + <enum bitpos="0" name="XR_FOVEATION_EYE_TRACKED_STATE_VALID_BIT_META" comment="Indicates whether or not foveation data is valid. This can happen if the eye tracker is obscured, the camera has dirt, or eye lid is closed, etc."/> + </enums> + + <!-- flags for XR_FB_composition_layer_secure_content --> + <enums name="XrCompositionLayerSecureContentFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_COMPOSITION_LAYER_SECURE_CONTENT_EXCLUDE_LAYER_BIT_FB" comment="Indicates the layer will only be visible inside the HMD, and not visible to external sources"/> + <enum bitpos="1" name="XR_COMPOSITION_LAYER_SECURE_CONTENT_REPLACE_LAYER_BIT_FB" comment="Indicates the layer will be displayed inside the HMD, but replaced by proxy content when written to external sources"/> + </enums> + + <!-- enums for XR_FB_spatial_entity --> + <enums name="XrSpaceComponentTypeFB" type="enum"> + <enum value="0" name="XR_SPACE_COMPONENT_TYPE_LOCATABLE_FB" comment="Enables tracking the 6 DOF pose of the slink:XrSpace with flink:xrLocateSpace."/> + <enum value="1" name="XR_SPACE_COMPONENT_TYPE_STORABLE_FB" comment="Enables persistence operations: save and erase."/> + <enum value="2" name="XR_SPACE_COMPONENT_TYPE_SHARABLE_FB" comment="Enables sharing of spatial entities."/> + <enum value="3" name="XR_SPACE_COMPONENT_TYPE_BOUNDED_2D_FB" comment="Bounded 2D component."/> + <enum value="4" name="XR_SPACE_COMPONENT_TYPE_BOUNDED_3D_FB" comment="Bounded 3D component."/> + <enum value="5" name="XR_SPACE_COMPONENT_TYPE_SEMANTIC_LABELS_FB" comment="Semantic labels component."/> + <enum value="6" name="XR_SPACE_COMPONENT_TYPE_ROOM_LAYOUT_FB" comment="Room layout component."/> + <enum value="7" name="XR_SPACE_COMPONENT_TYPE_SPACE_CONTAINER_FB" comment="Space container component."/> + </enums> + + <!-- enums for XR_FB_foveation_configuration --> + <enums name="XrFoveationLevelFB" type="enum"> + <enum value="0" name="XR_FOVEATION_LEVEL_NONE_FB" comment="No foveation"/> + <enum value="1" name="XR_FOVEATION_LEVEL_LOW_FB" comment="Less foveation (higher periphery visual fidelity, lower performance)"/> + <enum value="2" name="XR_FOVEATION_LEVEL_MEDIUM_FB" comment="Medium foveation (medium periphery visual fidelity, medium performance)"/> + <enum value="3" name="XR_FOVEATION_LEVEL_HIGH_FB" comment="High foveation (lower periphery visual fidelity, higher performance)"/> + </enums> + <enums name="XrFoveationDynamicFB" type="enum"> + <enum value="0" name="XR_FOVEATION_DYNAMIC_DISABLED_FB" comment="Static foveation at the maximum desired level"/> + <enum value="1" name="XR_FOVEATION_DYNAMIC_LEVEL_ENABLED_FB" comment="Dynamic changing foveation based on performance headroom available up to the maximum desired level"/> + </enums> + + <!-- enums for XR_FB_triangle_mesh --> + <enums name="XrWindingOrderFB" type="enum"> + <enum value="0" name="XR_WINDING_ORDER_UNKNOWN_FB" comment="Winding order is unknown and the runtime cannot make any assumptions on the triangle orientation"/> + <enum value="1" name="XR_WINDING_ORDER_CW_FB" comment="Clockwise winding order"/> + <enum value="2" name="XR_WINDING_ORDER_CCW_FB" comment="Counter-clockwise winding order"/> + </enums> + <enums name="XrTriangleMeshFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_TRIANGLE_MESH_MUTABLE_BIT_FB" comment="The triangle mesh is mutable (can be modified after it is created)."/> + </enums> + + <!-- enums for XR_FB_passthrough --> + <enums name="XrPassthroughLayerPurposeFB" type="enum"> + <enum value="0" name="XR_PASSTHROUGH_LAYER_PURPOSE_RECONSTRUCTION_FB" comment="Reconstruction passthrough (full screen environment)"/> + <enum value="1" name="XR_PASSTHROUGH_LAYER_PURPOSE_PROJECTED_FB" comment="Projected passthrough (using a custom surface)"/> + </enums> + <enums name="XrPassthroughFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_PASSTHROUGH_IS_RUNNING_AT_CREATION_BIT_FB" comment="The object (passthrough, layer) is running at creation."/> + <enum bitpos="1" name="XR_PASSTHROUGH_LAYER_DEPTH_BIT_FB" comment="The passthrough system sends depth information to the compositor. Only applicable to layer objects."/> + </enums> + <enums name="XrPassthroughStateChangedFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_PASSTHROUGH_STATE_CHANGED_REINIT_REQUIRED_BIT_FB" comment="Passthrough system requires reinitialization."/> + <enum bitpos="1" name="XR_PASSTHROUGH_STATE_CHANGED_NON_RECOVERABLE_ERROR_BIT_FB" comment="Non-recoverable error has occurred. A device reboot or a firmware update may be required."/> + <enum bitpos="2" name="XR_PASSTHROUGH_STATE_CHANGED_RECOVERABLE_ERROR_BIT_FB" comment="A recoverable error has occurred. The runtime will attempt to recover, but some functionality may be temporarily unavailable."/> + <enum bitpos="3" name="XR_PASSTHROUGH_STATE_CHANGED_RESTORED_ERROR_BIT_FB" comment="The runtime has recovered from a previous error and is functioning normally."/> + </enums> + <enums name="XrPassthroughCapabilityFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_PASSTHROUGH_CAPABILITY_BIT_FB" comment="The system supports passthrough."/> + <enum bitpos="1" name="XR_PASSTHROUGH_CAPABILITY_COLOR_BIT_FB" comment="The system can show passthrough with realistic colors. ename:XR_PASSTHROUGH_CAPABILITY_BIT_FB must: be set if ename:XR_PASSTHROUGH_CAPABILITY_COLOR_BIT_FB is set."/> + <enum bitpos="2" name="XR_PASSTHROUGH_CAPABILITY_LAYER_DEPTH_BIT_FB" comment="The system supports passthrough layers composited using depth testing. ename:XR_PASSTHROUGH_CAPABILITY_BIT_FB must: be set if ename:XR_PASSTHROUGH_CAPABILITY_LAYER_DEPTH_BIT_FB is set."/> + </enums> + + <!-- enums for XR_FB_spatial_entity_query --> + <enums name="XrSpaceQueryActionFB" type="enum"> + <enum value="0" name="XR_SPACE_QUERY_ACTION_LOAD_FB" comment="Tells the query to perform a load operation on any slink:XrSpace returned by the query."/> + </enums> + + <!-- enums for XR_FB_spatial_entity_storage --> + <enums name="XrSpaceStorageLocationFB" type="enum"> + <enum value="0" name="XR_SPACE_STORAGE_LOCATION_INVALID_FB" comment="Invalid storage location"/> + <enum value="1" name="XR_SPACE_STORAGE_LOCATION_LOCAL_FB" comment="Local device storage"/> + <enum value="2" name="XR_SPACE_STORAGE_LOCATION_CLOUD_FB" comment="Cloud storage"/> + </enums> + <enums name="XrSpacePersistenceModeFB" type="enum"> + <enum value="0" name="XR_SPACE_PERSISTENCE_MODE_INVALID_FB" comment="Invalid storage persistence"/> + <enum value="1" name="XR_SPACE_PERSISTENCE_MODE_INDEFINITE_FB" comment="Store slink:XrSpace indefinitely, or until erased"/> + </enums> + + <!-- enums for XR_META_spatial_entity_semantic_label --> + <enums name="XrSemanticLabelMETA" type="enum"> + <enum value="0" name="XR_SEMANTIC_LABEL_UNKNOWN_META" comment="Unknown. This is a valid label that is used when the runtime is not able to classify the entity using another label, or when the application does not recognize the label."/> + <enum value="1" name="XR_SEMANTIC_LABEL_FLOOR_META" comment="Floor of a room or space."/> + <enum value="2" name="XR_SEMANTIC_LABEL_CEILING_META" comment="Ceiling of a room or space."/> + <enum value="3" name="XR_SEMANTIC_LABEL_WALL_FACE_META" comment="Wall face of a room or space. Wall faces, along with invisible wall faces, are used to define the outer boundary of a room."/> + <enum value="4" name="XR_SEMANTIC_LABEL_INNER_WALL_FACE_META" comment="Inner wall face, which is a wall face that exists inside a room and is not connected to the outer boundary of the room. For example, a pillar that exists at the center of a room may: be represented by using four inner wall faces."/> + <enum value="5" name="XR_SEMANTIC_LABEL_INVISIBLE_WALL_FACE_META" comment="Invisible wall face, which is used to conceptually separate a space (e.g., separate a living space from a kitchen space in an open floor plan house even though there is no real wall between the two spaces)."/> + <enum value="6" name="XR_SEMANTIC_LABEL_DOOR_FRAME_META" comment="Door frame, which usually exists on a wall face."/> + <enum value="7" name="XR_SEMANTIC_LABEL_WINDOW_FRAME_META" comment="Window frame, which usually exists on a wall face."/> + </enums> + + <!-- enums for XR_META_boundary_visibility --> + <enums name="XrBoundaryVisibilityMETA" type="enum"> + <enum value="1" name="XR_BOUNDARY_VISIBILITY_NOT_SUPPRESSED_META" comment="Boundary visibility is not suppressed."/> + <enum value="2" name="XR_BOUNDARY_VISIBILITY_SUPPRESSED_META" comment="Boundary visibility is suppressed."/> + </enums> + + <!-- flags for XR_FB_scene --> + <enums name="XrSemanticLabelsSupportFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_SEMANTIC_LABELS_SUPPORT_MULTIPLE_SEMANTIC_LABELS_BIT_FB" comment="If set, and the runtime reports the pname:extensionVersion as 2 or greater, the runtime may: return multiple semantic labels separated by a comma without spaces. Otherwise, the runtime must: return a single semantic label."/> + <enum bitpos="1" name="XR_SEMANTIC_LABELS_SUPPORT_ACCEPT_DESK_TO_TABLE_MIGRATION_BIT_FB" comment="If set, and the runtime reports the pname:extensionVersion as 3 or greater, the runtime must: return "TABLE" instead of "DESK" as a semantic label to the application. Otherwise, the runtime must: return "DESK" instead of "TABLE" as a semantic label to the application, when applicable."/> + <enum bitpos="2" name="XR_SEMANTIC_LABELS_SUPPORT_ACCEPT_INVISIBLE_WALL_FACE_BIT_FB" comment="If set, and the runtime reports the pname:extensionVersion as 4 or greater, the runtime may: return "INVISIBLE_WALL_FACE" instead of "WALL_FACE" as a semantic label to the application in order to represent an invisible wall used to conceptually separate a space (e.g., separate a living space from a kitchen space in an open floor plan house even though there is no real wall between the two spaces) instead of a real wall. Otherwise, the runtime must: return "WALL_FACE" as a semantic label to the application in order to represent both an invisible and real wall, when applicable."/> + </enums> + + <!-- enums for XR_META_local_dimming --> + <enums name="XrLocalDimmingModeMETA" type="enum"> + <enum value="0" name="XR_LOCAL_DIMMING_MODE_OFF_META" comment="Local dimming is turned off by default for the current submitted frame. This is the same as not chaining elink:XrLocalDimmingModeMETA."/> + <enum value="1" name="XR_LOCAL_DIMMING_MODE_ON_META" comment="Local dimming is turned on for the current submitted frame."/> + </enums> + + <!-- flags for XR_FB_hand_tracking_aim --> + <enums name="XrHandTrackingAimFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_HAND_TRACKING_AIM_COMPUTED_BIT_FB" comment="Aiming data is computed from additional sources beyond the hand data in the base structure"/> + <enum bitpos="1" name="XR_HAND_TRACKING_AIM_VALID_BIT_FB" comment="Aiming data is valid"/> + <enum bitpos="2" name="XR_HAND_TRACKING_AIM_INDEX_PINCHING_BIT_FB" comment="Index finger pinch discrete signal"/> + <enum bitpos="3" name="XR_HAND_TRACKING_AIM_MIDDLE_PINCHING_BIT_FB" comment="Middle finger pinch discrete signal"/> + <enum bitpos="4" name="XR_HAND_TRACKING_AIM_RING_PINCHING_BIT_FB" comment="Ring finger pinch discrete signal"/> + <enum bitpos="5" name="XR_HAND_TRACKING_AIM_LITTLE_PINCHING_BIT_FB" comment="Little finger pinch discrete signal"/> + <enum bitpos="6" name="XR_HAND_TRACKING_AIM_SYSTEM_GESTURE_BIT_FB" comment="System gesture is active"/> + <enum bitpos="7" name="XR_HAND_TRACKING_AIM_DOMINANT_HAND_BIT_FB" comment="Hand is currently marked as dominant for the system"/> + <enum bitpos="8" name="XR_HAND_TRACKING_AIM_MENU_PRESSED_BIT_FB" comment="System menu gesture is active"/> + </enums> + + <!-- flags for XR_BD_body_tracking_auxiliary_metrics --> + <enums name="XrSpaceAccelerationFlagBitsBD" type="bitmask"> + <enum bitpos="0" name="XR_SPACE_ACCELERATION_LINEAR_VALID_BIT_BD" comment="Linear acceleration."/> + <enum bitpos="1" name="XR_SPACE_ACCELERATION_ANGULAR_VALID_BIT_BD" comment="Angular acceleration."/> + </enums> + + <!-- flags for XR_FB_keyboard_tracking query state --> + <enums name="XrKeyboardTrackingFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_KEYBOARD_TRACKING_EXISTS_BIT_FB" comment="indicates that the system has a physically tracked keyboard to report. If not set then no other bits should be considered to be valid or meaningful. If set either XR_KEYBOARD_TRACKING_LOCAL_BIT_FB or XR_KEYBOARD_TRACKING_REMOTE_BIT_FB must also be set."/> + <enum bitpos="1" name="XR_KEYBOARD_TRACKING_LOCAL_BIT_FB" comment="indicates that the physically tracked keyboard is intended to be used in a local pairing with the system. Mutually exclusive with XR_KEYBOARD_TRACKING_REMOTE_BIT_FB."/> + <enum bitpos="2" name="XR_KEYBOARD_TRACKING_REMOTE_BIT_FB" comment="indicates that the physically tracked keyboard is intended to be used while paired to a separate remote computing device. Mutually exclusive with XR_KEYBOARD_TRACKING_LOCAL_BIT_FB."/> + <enum bitpos="3" name="XR_KEYBOARD_TRACKING_CONNECTED_BIT_FB" comment="indicates that the physically tracked keyboard is actively connected to the headset and capable of sending key data"/> + </enums> + + <!-- flags for XR_FB_keyboard_tracking query --> + <enums name="XrKeyboardTrackingQueryFlagBitsFB" type="bitmask"> + <enum bitpos="1" name="XR_KEYBOARD_TRACKING_QUERY_LOCAL_BIT_FB" comment="indicates the query is for the physically tracked keyboard that is intended to be used in a local pairing with the System. Mutually exclusive with XR_KEYBOARD_TRACKING_QUERY_REMOTE_BIT_FB."/> + <enum bitpos="2" name="XR_KEYBOARD_TRACKING_QUERY_REMOTE_BIT_FB" comment="indicates the query is for the physically tracked keyboard that may be connected to a separate remote computing device. Mutually exclusive with XR_KEYBOARD_TRACKING_QUERY_LOCAL_BIT_FB."/> + </enums> + + <!-- flags for XR_FB_space_warp --> + <enums name="XrCompositionLayerSpaceWarpInfoFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_COMPOSITION_LAYER_SPACE_WARP_INFO_FRAME_SKIP_BIT_FB" comment="Skip current frame's space warp extrapolation"/> + </enums> + + <!-- flags for XR_FB_render_model --> + <enums name="XrRenderModelFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_RENDER_MODEL_SUPPORTS_GLTF_2_0_SUBSET_1_BIT_FB" comment="Minimal level of support. Can only contain a single mesh. Can only contain a single texture. Can not contain transparency. Assumes unlit rendering. Requires Extension KHR_texturebasisu."/> + <enum bitpos="1" name="XR_RENDER_MODEL_SUPPORTS_GLTF_2_0_SUBSET_2_BIT_FB" comment="All of XR_RENDER_MODEL_SUPPORTS_GLTF_2_0_SUBSET_1_BIT_FB support plus: Multiple meshes. Multiple Textures. Texture Transparency."/> + </enums> + + <!-- enums for XR_HTC_facial_tracking --> + <enums name="XrFacialTrackingTypeHTC" type="enum"> + <enum value="1" name="XR_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC" comment="Specifies this handle will observe eye expressions, with values indexed by elink:XrEyeExpressionHTC whose count is dlink:XR_FACIAL_EXPRESSION_EYE_COUNT_HTC."/> + <enum value="2" name="XR_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC" comment="Specifies this handle will observe lip expressions, with values indexed by elink:XrLipExpressionHTC whose count is dlink:XR_FACIAL_EXPRESSION_LIP_COUNT_HTC."/> + </enums> + + <!-- enums for XR_HTC_passthrough --> + <enums name="XrPassthroughFormHTC" type="enum"> + <enum value="0" name="XR_PASSTHROUGH_FORM_PLANAR_HTC" comment="Presents the passthrough with full of the entire screen."/> + <enum value="1" name="XR_PASSTHROUGH_FORM_PROJECTED_HTC" comment="Presents the passthrough projecting onto a custom mesh."/> + </enums> + + <enums name="XrEyeExpressionHTC" type="enum"> + <enum value="0" name="XR_EYE_EXPRESSION_LEFT_BLINK_HTC"/> + <enum value="1" name="XR_EYE_EXPRESSION_LEFT_WIDE_HTC"/> + <enum value="2" name="XR_EYE_EXPRESSION_RIGHT_BLINK_HTC"/> + <enum value="3" name="XR_EYE_EXPRESSION_RIGHT_WIDE_HTC"/> + <enum value="4" name="XR_EYE_EXPRESSION_LEFT_SQUEEZE_HTC"/> + <enum value="5" name="XR_EYE_EXPRESSION_RIGHT_SQUEEZE_HTC"/> + <enum value="6" name="XR_EYE_EXPRESSION_LEFT_DOWN_HTC"/> + <enum value="7" name="XR_EYE_EXPRESSION_RIGHT_DOWN_HTC"/> + <enum value="8" name="XR_EYE_EXPRESSION_LEFT_OUT_HTC"/> + <enum value="9" name="XR_EYE_EXPRESSION_RIGHT_IN_HTC"/> + <enum value="10" name="XR_EYE_EXPRESSION_LEFT_IN_HTC"/> + <enum value="11" name="XR_EYE_EXPRESSION_RIGHT_OUT_HTC"/> + <enum value="12" name="XR_EYE_EXPRESSION_LEFT_UP_HTC"/> + <enum value="13" name="XR_EYE_EXPRESSION_RIGHT_UP_HTC"/> + </enums> + + <enums name="XrLipExpressionHTC" type="enum"> + <enum value="0" name="XR_LIP_EXPRESSION_JAW_RIGHT_HTC"/> + <enum value="1" name="XR_LIP_EXPRESSION_JAW_LEFT_HTC"/> + <enum value="2" name="XR_LIP_EXPRESSION_JAW_FORWARD_HTC"/> + <enum value="3" name="XR_LIP_EXPRESSION_JAW_OPEN_HTC"/> + <enum value="4" name="XR_LIP_EXPRESSION_MOUTH_APE_SHAPE_HTC"/> + <enum value="5" name="XR_LIP_EXPRESSION_MOUTH_UPPER_RIGHT_HTC"/> + <enum value="6" name="XR_LIP_EXPRESSION_MOUTH_UPPER_LEFT_HTC"/> + <enum value="7" name="XR_LIP_EXPRESSION_MOUTH_LOWER_RIGHT_HTC"/> + <enum value="8" name="XR_LIP_EXPRESSION_MOUTH_LOWER_LEFT_HTC"/> + <enum value="9" name="XR_LIP_EXPRESSION_MOUTH_UPPER_OVERTURN_HTC"/> + <enum value="10" name="XR_LIP_EXPRESSION_MOUTH_LOWER_OVERTURN_HTC"/> + <enum value="11" name="XR_LIP_EXPRESSION_MOUTH_POUT_HTC"/> + <enum value="12" name="XR_LIP_EXPRESSION_MOUTH_RAISER_RIGHT_HTC"/> + <enum value="13" name="XR_LIP_EXPRESSION_MOUTH_RAISER_LEFT_HTC"/> + <enum value="14" name="XR_LIP_EXPRESSION_MOUTH_STRETCHER_RIGHT_HTC"/> + <enum value="15" name="XR_LIP_EXPRESSION_MOUTH_STRETCHER_LEFT_HTC"/> + <enum value="16" name="XR_LIP_EXPRESSION_CHEEK_PUFF_RIGHT_HTC"/> + <enum value="17" name="XR_LIP_EXPRESSION_CHEEK_PUFF_LEFT_HTC"/> + <enum value="18" name="XR_LIP_EXPRESSION_CHEEK_SUCK_HTC"/> + <enum value="19" name="XR_LIP_EXPRESSION_MOUTH_UPPER_UPRIGHT_HTC"/> + <enum value="20" name="XR_LIP_EXPRESSION_MOUTH_UPPER_UPLEFT_HTC"/> + <enum value="21" name="XR_LIP_EXPRESSION_MOUTH_LOWER_DOWNRIGHT_HTC"/> + <enum value="22" name="XR_LIP_EXPRESSION_MOUTH_LOWER_DOWNLEFT_HTC"/> + <enum value="23" name="XR_LIP_EXPRESSION_MOUTH_UPPER_INSIDE_HTC"/> + <enum value="24" name="XR_LIP_EXPRESSION_MOUTH_LOWER_INSIDE_HTC"/> + <enum value="25" name="XR_LIP_EXPRESSION_MOUTH_LOWER_OVERLAY_HTC"/> + <enum value="26" name="XR_LIP_EXPRESSION_TONGUE_LONGSTEP1_HTC"/> + <enum value="27" name="XR_LIP_EXPRESSION_TONGUE_LEFT_HTC"/> + <enum value="28" name="XR_LIP_EXPRESSION_TONGUE_RIGHT_HTC"/> + <enum value="29" name="XR_LIP_EXPRESSION_TONGUE_UP_HTC"/> + <enum value="30" name="XR_LIP_EXPRESSION_TONGUE_DOWN_HTC"/> + <enum value="31" name="XR_LIP_EXPRESSION_TONGUE_ROLL_HTC"/> + <enum value="32" name="XR_LIP_EXPRESSION_TONGUE_LONGSTEP2_HTC"/> + <enum value="33" name="XR_LIP_EXPRESSION_TONGUE_UPRIGHT_MORPH_HTC"/> + <enum value="34" name="XR_LIP_EXPRESSION_TONGUE_UPLEFT_MORPH_HTC"/> + <enum value="35" name="XR_LIP_EXPRESSION_TONGUE_DOWNRIGHT_MORPH_HTC"/> + <enum value="36" name="XR_LIP_EXPRESSION_TONGUE_DOWNLEFT_MORPH_HTC"/> + </enums> + + <!-- enums for XR_ANDROID_light_estimation --> + <enums name="XrLightEstimateStateANDROID" type="enum"> + <enum value="0" name="XR_LIGHT_ESTIMATE_STATE_VALID_ANDROID" comment="The light estimate is valid"/> + <enum value="1" name="XR_LIGHT_ESTIMATE_STATE_INVALID_ANDROID" comment="The light estimate is invalid"/> + </enums> + <enums name="XrSphericalHarmonicsKindANDROID" type="enum"> + <enum value="0" name="XR_SPHERICAL_HARMONICS_KIND_TOTAL_ANDROID" comment="The spherical harmonic coefficients represent the environment light radiance function, including the contribution from the main light."/> + <enum value="1" name="XR_SPHERICAL_HARMONICS_KIND_AMBIENT_ANDROID" comment="The spherical harmonic coefficients represent the environment light radiance function, excluding the contribution from the main light."/> + </enums> + + <!-- flags for XR_ALMALENCE_digital_lens_control --> + <enums name="XrDigitalLensControlFlagBitsALMALENCE" type="bitmask"> + <enum bitpos="0" name="XR_DIGITAL_LENS_CONTROL_PROCESSING_DISABLE_BIT_ALMALENCE" comment="disables Digital Lens processing of render textures"/> + </enums> + + <!-- flags for XR_FB_composition_layer_settings --> + <enums name="XrCompositionLayerSettingsFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_COMPOSITION_LAYER_SETTINGS_NORMAL_SUPER_SAMPLING_BIT_FB" comment="Indicates compositor may: use layer texture supersampling."/> + <enum bitpos="1" name="XR_COMPOSITION_LAYER_SETTINGS_QUALITY_SUPER_SAMPLING_BIT_FB" comment="Indicates compositor may: use high quality layer texture supersampling."/> + <enum bitpos="2" name="XR_COMPOSITION_LAYER_SETTINGS_NORMAL_SHARPENING_BIT_FB" comment="Indicates compositor may: use layer texture sharpening."/> + <enum bitpos="3" name="XR_COMPOSITION_LAYER_SETTINGS_QUALITY_SHARPENING_BIT_FB" comment="Indicates compositor may: use high quality layer texture sharpening."/> + </enums> + + <!-- flags for XR_OCULUS_external_camera --> + <enums name="XrExternalCameraStatusFlagBitsOCULUS" type="bitmask"> + <enum bitpos="0" name="XR_EXTERNAL_CAMERA_STATUS_CONNECTED_BIT_OCULUS" comment="External camera is connected"/> + <enum bitpos="1" name="XR_EXTERNAL_CAMERA_STATUS_CALIBRATING_BIT_OCULUS" comment="External camera is undergoing calibration"/> + <enum bitpos="2" name="XR_EXTERNAL_CAMERA_STATUS_CALIBRATION_FAILED_BIT_OCULUS" comment="External camera has tried and failed calibration"/> + <enum bitpos="3" name="XR_EXTERNAL_CAMERA_STATUS_CALIBRATED_BIT_OCULUS" comment="External camera has tried and passed calibration"/> + <enum bitpos="4" name="XR_EXTERNAL_CAMERA_STATUS_CAPTURING_BIT_OCULUS" comment="External camera is capturing"/> + </enums> + + <enums name="XrExternalCameraAttachedToDeviceOCULUS" type="enum"> + <enum value="0" name="XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_NONE_OCULUS" comment="External camera is at a fixed point in LOCAL space"/> + <enum value="1" name="XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_HMD_OCULUS" comment="External camera is attached to the HMD"/> + <enum value="2" name="XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_LTOUCH_OCULUS" comment="External camera is attached to a left Touch controller"/> + <enum value="3" name="XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_RTOUCH_OCULUS" comment="External camera is attached to a right Touch controller"/> + </enums> + + <!-- enums for XR_META_passthrough_color_lut--> + <enums name="XrPassthroughColorLutChannelsMETA" type="enum"> + <enum value="1" name="XR_PASSTHROUGH_COLOR_LUT_CHANNELS_RGB_META"/> + <enum value="2" name="XR_PASSTHROUGH_COLOR_LUT_CHANNELS_RGBA_META"/> + </enums> + + <!-- flags for XR_META_performance_metrics --> + <enums name="XrPerformanceMetricsCounterFlagBitsMETA" type="bitmask"> + <enum bitpos="0" name="XR_PERFORMANCE_METRICS_COUNTER_ANY_VALUE_VALID_BIT_META" comment="Indicates any of the values in XrPerformanceMetricsCounterMETA is valid."/> + <enum bitpos="1" name="XR_PERFORMANCE_METRICS_COUNTER_UINT_VALUE_VALID_BIT_META" comment="Indicates the uintValue in XrPerformanceMetricsCounterMETA is valid."/> + <enum bitpos="2" name="XR_PERFORMANCE_METRICS_COUNTER_FLOAT_VALUE_VALID_BIT_META" comment="Indicates the floatValue in XrPerformanceMetricsCounterMETA is valid."/> + </enums> + + <enums name="XrPerformanceMetricsCounterUnitMETA" type="enum"> + <enum value="0" name="XR_PERFORMANCE_METRICS_COUNTER_UNIT_GENERIC_META" comment="the performance counter unit is generic (unspecified)."/> + <enum value="1" name="XR_PERFORMANCE_METRICS_COUNTER_UNIT_PERCENTAGE_META" comment="the performance counter unit is percentage (%)."/> + <enum value="2" name="XR_PERFORMANCE_METRICS_COUNTER_UNIT_MILLISECONDS_META" comment="the performance counter unit is millisecond."/> + <enum value="3" name="XR_PERFORMANCE_METRICS_COUNTER_UNIT_BYTES_META" comment="the performance counter unit is byte."/> + <enum value="4" name="XR_PERFORMANCE_METRICS_COUNTER_UNIT_HERTZ_META" comment="the performance counter unit is hertz (Hz)."/> + </enums> + + <!-- flags for XR_META_passthrough_preferences --> + <enums name="XrPassthroughPreferenceFlagBitsMETA" type="bitmask"> + <enum bitpos="0" name="XR_PASSTHROUGH_PREFERENCE_DEFAULT_TO_ACTIVE_BIT_META" comment="Indicates that the runtime recommends apps to default to a mixed reality experience with passthrough (if supported)."/> + </enums> + + <!-- enums for XR_HTC_foveation --> + <enums name="XrFoveationModeHTC" type="enum"> + <enum value="0" name="XR_FOVEATION_MODE_DISABLE_HTC" comment="No foveation"/> + <enum value="1" name="XR_FOVEATION_MODE_FIXED_HTC" comment="Apply system default setting with fixed clear FOV and periphery quality."/> + <enum value="2" name="XR_FOVEATION_MODE_DYNAMIC_HTC" comment="Allow system to set foveation dynamically according realtime system metric or other extensions."/> + <enum value="3" name="XR_FOVEATION_MODE_CUSTOM_HTC" comment="Allow application to set foveation with desired clear FOV, periphery quality, and focal center offset."/> + </enums> + <enums name="XrFoveationDynamicFlagBitsHTC" type="bitmask"> + <enum bitpos="0" name="XR_FOVEATION_DYNAMIC_LEVEL_ENABLED_BIT_HTC" comment="Allow system to set periphery pixel density dynamically."/> + <enum bitpos="1" name="XR_FOVEATION_DYNAMIC_CLEAR_FOV_ENABLED_BIT_HTC" comment="Allow system to set clear FOV degree dynamically."/> + <enum bitpos="2" name="XR_FOVEATION_DYNAMIC_FOCAL_CENTER_OFFSET_ENABLED_BIT_HTC" comment="Allow system to set focal center offset dynamically."/> + </enums> + <enums name="XrFoveationLevelHTC" type="enum"> + <enum value="0" name="XR_FOVEATION_LEVEL_NONE_HTC" comment="No foveation"/> + <enum value="1" name="XR_FOVEATION_LEVEL_LOW_HTC" comment="Light periphery pixel density drop and lower performance gain."/> + <enum value="2" name="XR_FOVEATION_LEVEL_MEDIUM_HTC" comment="Medium periphery pixel density drop and medium performance gain"/> + <enum value="3" name="XR_FOVEATION_LEVEL_HIGH_HTC" comment="Heavy periphery pixel density drop and higher performance gain"/> + </enums> + + <!-- XR_HTC_body_tracking --> + <enums name="XrBodyJointHTC" type="enum"> + <enum value="0" name="XR_BODY_JOINT_PELVIS_HTC"/> + <enum value="1" name="XR_BODY_JOINT_LEFT_HIP_HTC"/> + <enum value="2" name="XR_BODY_JOINT_LEFT_KNEE_HTC"/> + <enum value="3" name="XR_BODY_JOINT_LEFT_ANKLE_HTC"/> + <enum value="4" name="XR_BODY_JOINT_LEFT_FEET_HTC"/> + <enum value="5" name="XR_BODY_JOINT_RIGHT_HIP_HTC"/> + <enum value="6" name="XR_BODY_JOINT_RIGHT_KNEE_HTC"/> + <enum value="7" name="XR_BODY_JOINT_RIGHT_ANKLE_HTC"/> + <enum value="8" name="XR_BODY_JOINT_RIGHT_FEET_HTC"/> + <enum value="9" name="XR_BODY_JOINT_WAIST_HTC"/> + <enum value="10" name="XR_BODY_JOINT_SPINE_LOWER_HTC"/> + <enum value="11" name="XR_BODY_JOINT_SPINE_MIDDLE_HTC"/> + <enum value="12" name="XR_BODY_JOINT_SPINE_HIGH_HTC"/> + <enum value="13" name="XR_BODY_JOINT_CHEST_HTC"/> + <enum value="14" name="XR_BODY_JOINT_NECK_HTC"/> + <enum value="15" name="XR_BODY_JOINT_HEAD_HTC"/> + <enum value="16" name="XR_BODY_JOINT_LEFT_CLAVICLE_HTC"/> + <enum value="17" name="XR_BODY_JOINT_LEFT_SCAPULA_HTC"/> + <enum value="18" name="XR_BODY_JOINT_LEFT_ARM_HTC"/> + <enum value="19" name="XR_BODY_JOINT_LEFT_ELBOW_HTC"/> + <enum value="20" name="XR_BODY_JOINT_LEFT_WRIST_HTC"/> + <enum value="21" name="XR_BODY_JOINT_RIGHT_CLAVICLE_HTC"/> + <enum value="22" name="XR_BODY_JOINT_RIGHT_SCAPULA_HTC"/> + <enum value="23" name="XR_BODY_JOINT_RIGHT_ARM_HTC"/> + <enum value="24" name="XR_BODY_JOINT_RIGHT_ELBOW_HTC"/> + <enum value="25" name="XR_BODY_JOINT_RIGHT_WRIST_HTC"/> + </enums> + <enums name="XrBodyJointSetHTC" type="enum"> + <enum value="0" name="XR_BODY_JOINT_SET_FULL_HTC"/> + </enums> + + <enums name="XrBodyJointConfidenceHTC" type="enum"> + <enum value="0" name="XR_BODY_JOINT_CONFIDENCE_NONE_HTC"/> + <enum value="1" name="XR_BODY_JOINT_CONFIDENCE_LOW_HTC"/> + <enum value="2" name="XR_BODY_JOINT_CONFIDENCE_HIGH_HTC"/> + </enums> + + <!-- enums for XR_ANDROID_performance_metrics --> + <enums name="XrPerformanceMetricsCounterUnitANDROID" type="enum"> + <enum value="0" name="XR_PERFORMANCE_METRICS_COUNTER_UNIT_GENERIC_ANDROID" comment="The performance counter unit is generic (unspecified)."/> + <enum value="1" name="XR_PERFORMANCE_METRICS_COUNTER_UNIT_PERCENTAGE_ANDROID" comment="The performance counter unit is percentage (%)."/> + <enum value="2" name="XR_PERFORMANCE_METRICS_COUNTER_UNIT_MILLISECONDS_ANDROID" comment="The performance counter unit is millisecond."/> + <enum value="3" name="XR_PERFORMANCE_METRICS_COUNTER_UNIT_BYTES_ANDROID" comment="The performance counter unit is byte."/> + <enum value="4" name="XR_PERFORMANCE_METRICS_COUNTER_UNIT_HERTZ_ANDROID" comment="The performance counter unit is hertz (Hz)."/> + </enums> + <enums name="XrPerformanceMetricsCounterFlagBitsANDROID" type="bitmask"> + <enum bitpos="0" name="XR_PERFORMANCE_METRICS_COUNTER_ANY_VALUE_VALID_BIT_ANDROID" comment="Indicates any of the values in XrPerformanceMetricsCounterANDROID is valid."/> + <enum bitpos="1" name="XR_PERFORMANCE_METRICS_COUNTER_UINT_VALUE_VALID_BIT_ANDROID" comment="Indicates the uintValue in XrPerformanceMetricsCounterANDROID is valid."/> + <enum bitpos="2" name="XR_PERFORMANCE_METRICS_COUNTER_FLOAT_VALUE_VALID_BIT_ANDROID" comment="Indicates the floatValue in XrPerformanceMetricsCounterANDROID is valid."/> + </enums> + + <!-- enums for XR_FB_composition_layer_depth_test --> + <enums name="XrCompareOpFB" type="enum"> + <enum value="0" name="XR_COMPARE_OP_NEVER_FB" comment="Comparison is never true."/> + <enum value="1" name="XR_COMPARE_OP_LESS_FB" comment="Comparison is true if source less than is destination."/> + <enum value="2" name="XR_COMPARE_OP_EQUAL_FB" comment="Comparison is true if source is equal to destination."/> + <enum value="3" name="XR_COMPARE_OP_LESS_OR_EQUAL_FB" comment="Comparison is true if source is less than or equal to destination."/> + <enum value="4" name="XR_COMPARE_OP_GREATER_FB" comment="Comparison is true if source is greater than destination."/> + <enum value="5" name="XR_COMPARE_OP_NOT_EQUAL_FB" comment="Comparison is true if source is not equal to destination."/> + <enum value="6" name="XR_COMPARE_OP_GREATER_OR_EQUAL_FB" comment="Comparison is true if source is greater than or equal to destination."/> + <enum value="7" name="XR_COMPARE_OP_ALWAYS_FB" comment="Comparison is always true."/> + </enums> + + <!-- enums for XR_ANDROID_face_tracking --> + <enums name="XrFaceParameterIndicesANDROID" type="enum"> + <enum value="0" name="XR_FACE_PARAMETER_INDICES_BROW_LOWERER_L_ANDROID" comment="The left brow lowerer blendshape parameter."/> + <enum value="1" name="XR_FACE_PARAMETER_INDICES_BROW_LOWERER_R_ANDROID" comment="The right brow lowerer blendshape parameter."/> + <enum value="2" name="XR_FACE_PARAMETER_INDICES_CHEEK_PUFF_L_ANDROID" comment="The left cheek puff blendshape parameter."/> + <enum value="3" name="XR_FACE_PARAMETER_INDICES_CHEEK_PUFF_R_ANDROID" comment="The right cheek puff blendshape parameter."/> + <enum value="4" name="XR_FACE_PARAMETER_INDICES_CHEEK_RAISER_L_ANDROID" comment="The left cheek raiser blendshape parameter."/> + <enum value="5" name="XR_FACE_PARAMETER_INDICES_CHEEK_RAISER_R_ANDROID" comment="The right cheek raiser blendshape parameter."/> + <enum value="6" name="XR_FACE_PARAMETER_INDICES_CHEEK_SUCK_L_ANDROID" comment="The left cheek suck blendshape parameter."/> + <enum value="7" name="XR_FACE_PARAMETER_INDICES_CHEEK_SUCK_R_ANDROID" comment="The right cheek suck blendshape parameter."/> + <enum value="8" name="XR_FACE_PARAMETER_INDICES_CHIN_RAISER_B_ANDROID" comment="The bottom chin raiser blendshape parameter."/> + <enum value="9" name="XR_FACE_PARAMETER_INDICES_CHIN_RAISER_T_ANDROID" comment="The top chin raiser blendshape parameter."/> + <enum value="10" name="XR_FACE_PARAMETER_INDICES_DIMPLER_L_ANDROID" comment="The left dimpler blendshape parameter."/> + <enum value="11" name="XR_FACE_PARAMETER_INDICES_DIMPLER_R_ANDROID" comment="The right dimpler lowerer blendshape parameter."/> + <enum value="12" name="XR_FACE_PARAMETER_INDICES_EYES_CLOSED_L_ANDROID" comment="The left eyes closed blendshape parameter."/> + <enum value="13" name="XR_FACE_PARAMETER_INDICES_EYES_CLOSED_R_ANDROID" comment="The right eyes closed blendshape parameter."/> + <enum value="14" name="XR_FACE_PARAMETER_INDICES_EYES_LOOK_DOWN_L_ANDROID" comment="The left eyes look down blendshape parameter."/> + <enum value="15" name="XR_FACE_PARAMETER_INDICES_EYES_LOOK_DOWN_R_ANDROID" comment="The right eyes look down blendshape parameter."/> + <enum value="16" name="XR_FACE_PARAMETER_INDICES_EYES_LOOK_LEFT_L_ANDROID" comment="The left look left blendshape parameter."/> + <enum value="17" name="XR_FACE_PARAMETER_INDICES_EYES_LOOK_LEFT_R_ANDROID" comment="The left look right blendshape parameter."/> + <enum value="18" name="XR_FACE_PARAMETER_INDICES_EYES_LOOK_RIGHT_L_ANDROID" comment="The right look left blendshape parameter."/> + <enum value="19" name="XR_FACE_PARAMETER_INDICES_EYES_LOOK_RIGHT_R_ANDROID" comment="The right look right blendshape parameter."/> + <enum value="20" name="XR_FACE_PARAMETER_INDICES_EYES_LOOK_UP_L_ANDROID" comment="The left eyes look up blendshape parameter."/> + <enum value="21" name="XR_FACE_PARAMETER_INDICES_EYES_LOOK_UP_R_ANDROID" comment="The right eyes look up blendshape parameter."/> + <enum value="22" name="XR_FACE_PARAMETER_INDICES_INNER_BROW_RAISER_L_ANDROID" comment="The left inner brow raiser blendshape parameter."/> + <enum value="23" name="XR_FACE_PARAMETER_INDICES_INNER_BROW_RAISER_R_ANDROID" comment="The right inner brow raiser blendshape parameter."/> + <enum value="24" name="XR_FACE_PARAMETER_INDICES_JAW_DROP_ANDROID" comment="The jaw drop blendshape parameter."/> + <enum value="25" name="XR_FACE_PARAMETER_INDICES_JAW_SIDEWAYS_LEFT_ANDROID" comment="The left jaw sideways blendshape parameter."/> + <enum value="26" name="XR_FACE_PARAMETER_INDICES_JAW_SIDEWAYS_RIGHT_ANDROID" comment="The right jaw sideways blendshape parameter."/> + <enum value="27" name="XR_FACE_PARAMETER_INDICES_JAW_THRUST_ANDROID" comment="The jaw thrust blendshape parameter."/> + <enum value="28" name="XR_FACE_PARAMETER_INDICES_LID_TIGHTENER_L_ANDROID" comment="The left lid tightener blendshape parameter."/> + <enum value="29" name="XR_FACE_PARAMETER_INDICES_LID_TIGHTENER_R_ANDROID" comment="The right lid tightener blendshape parameter."/> + <enum value="30" name="XR_FACE_PARAMETER_INDICES_LIP_CORNER_DEPRESSOR_L_ANDROID" comment="The left corner lip depressor blendshape parameter."/> + <enum value="31" name="XR_FACE_PARAMETER_INDICES_LIP_CORNER_DEPRESSOR_R_ANDROID" comment="The right corner lip depressor blendshape parameter."/> + <enum value="32" name="XR_FACE_PARAMETER_INDICES_LIP_CORNER_PULLER_L_ANDROID" comment="The left corner lip puller blendshape parameter."/> + <enum value="33" name="XR_FACE_PARAMETER_INDICES_LIP_CORNER_PULLER_R_ANDROID" comment="The right corner lip puller blendshape parameter."/> + <enum value="34" name="XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_LB_ANDROID" comment="The left bottom lip funneler blendshape parameter."/> + <enum value="35" name="XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_LT_ANDROID" comment="The left top lip funneler blendshape parameter."/> + <enum value="36" name="XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_RB_ANDROID" comment="The right bottom lip funneler blendshape parameter."/> + <enum value="37" name="XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_RT_ANDROID" comment="The right top lip funneler blendshape parameter."/> + <enum value="38" name="XR_FACE_PARAMETER_INDICES_LIP_PRESSOR_L_ANDROID" comment="The left lip pressor blendshape parameter."/> + <enum value="39" name="XR_FACE_PARAMETER_INDICES_LIP_PRESSOR_R_ANDROID" comment="The right lip pressor blendshape parameter."/> + <enum value="40" name="XR_FACE_PARAMETER_INDICES_LIP_PUCKER_L_ANDROID" comment="The left lip pucker blendshape parameter."/> + <enum value="41" name="XR_FACE_PARAMETER_INDICES_LIP_PUCKER_R_ANDROID" comment="The right lip pucker blendshape parameter."/> + <enum value="42" name="XR_FACE_PARAMETER_INDICES_LIP_STRETCHER_L_ANDROID" comment="The left lip stretcher blendshape parameter."/> + <enum value="43" name="XR_FACE_PARAMETER_INDICES_LIP_STRETCHER_R_ANDROID" comment="The right lip stretcher blendshape parameter."/> + <enum value="44" name="XR_FACE_PARAMETER_INDICES_LIP_SUCK_LB_ANDROID" comment="The left bottom lip suck blendshape parameter."/> + <enum value="45" name="XR_FACE_PARAMETER_INDICES_LIP_SUCK_LT_ANDROID" comment="The left top lip suck blendshape parameter."/> + <enum value="46" name="XR_FACE_PARAMETER_INDICES_LIP_SUCK_RB_ANDROID" comment="The right bottom lip suck blendshape parameter."/> + <enum value="47" name="XR_FACE_PARAMETER_INDICES_LIP_SUCK_RT_ANDROID" comment="The right top lip suck blendshape parameter."/> + <enum value="48" name="XR_FACE_PARAMETER_INDICES_LIP_TIGHTENER_L_ANDROID" comment="The left lip tightener blendshape parameter."/> + <enum value="49" name="XR_FACE_PARAMETER_INDICES_LIP_TIGHTENER_R_ANDROID" comment="The right lip tightener blendshape parameter."/> + <enum value="50" name="XR_FACE_PARAMETER_INDICES_LIPS_TOWARD_ANDROID" comment="The lips toward blendshape parameter."/> + <enum value="51" name="XR_FACE_PARAMETER_INDICES_LOWER_LIP_DEPRESSOR_L_ANDROID" comment="The left lower lip depressor blendshape parameter."/> + <enum value="52" name="XR_FACE_PARAMETER_INDICES_LOWER_LIP_DEPRESSOR_R_ANDROID" comment="The right lower lip depressor blendshape parameter."/> + <enum value="53" name="XR_FACE_PARAMETER_INDICES_MOUTH_LEFT_ANDROID" comment="The mouth move left blendshape parameter."/> + <enum value="54" name="XR_FACE_PARAMETER_INDICES_MOUTH_RIGHT_ANDROID" comment="The mouth move right blendshape parameter."/> + <enum value="55" name="XR_FACE_PARAMETER_INDICES_NOSE_WRINKLER_L_ANDROID" comment="The left nose wrinkler blendshape parameter."/> + <enum value="56" name="XR_FACE_PARAMETER_INDICES_NOSE_WRINKLER_R_ANDROID" comment="The right nose wrinkler blendshape parameter."/> + <enum value="57" name="XR_FACE_PARAMETER_INDICES_OUTER_BROW_RAISER_L_ANDROID" comment="The left outer brow raiser blendshape parameter."/> + <enum value="58" name="XR_FACE_PARAMETER_INDICES_OUTER_BROW_RAISER_R_ANDROID" comment="The right outer brow raiser blendshape parameter."/> + <enum value="59" name="XR_FACE_PARAMETER_INDICES_UPPER_LID_RAISER_L_ANDROID" comment="The left lid raiser blendshape parameter."/> + <enum value="60" name="XR_FACE_PARAMETER_INDICES_UPPER_LID_RAISER_R_ANDROID" comment="The right lid raiser blendshape parameter."/> + <enum value="61" name="XR_FACE_PARAMETER_INDICES_UPPER_LIP_RAISER_L_ANDROID" comment="The left lip raiser blendshape parameter."/> + <enum value="62" name="XR_FACE_PARAMETER_INDICES_UPPER_LIP_RAISER_R_ANDROID" comment="The right lip raiser blendshape parameter."/> + <enum value="63" name="XR_FACE_PARAMETER_INDICES_TONGUE_OUT_ANDROID" comment="The tongue out blendshape parameter."/> + <enum value="64" name="XR_FACE_PARAMETER_INDICES_TONGUE_LEFT_ANDROID" comment="The tongue left puller blendshape parameter."/> + <enum value="65" name="XR_FACE_PARAMETER_INDICES_TONGUE_RIGHT_ANDROID" comment="The right right puller blendshape parameter."/> + <enum value="66" name="XR_FACE_PARAMETER_INDICES_TONGUE_UP_ANDROID" comment="The right up puller blendshape parameter."/> + <enum value="67" name="XR_FACE_PARAMETER_INDICES_TONGUE_DOWN_ANDROID" comment="The right down puller blendshape parameter."/> + </enums> + <enums name="XrFaceTrackingStateANDROID" type="enum"> + <enum value="0" name="XR_FACE_TRACKING_STATE_PAUSED_ANDROID" comment="Indicates that face tracking is paused but may be resumed in the future."/> + <enum value="1" name="XR_FACE_TRACKING_STATE_STOPPED_ANDROID" comment="Tracking has stopped but the client still has an active face tracker."/> + <enum value="2" name="XR_FACE_TRACKING_STATE_TRACKING_ANDROID" comment="The face is currently tracked and its pose is current."/> + </enums> + <enums name="XrFaceConfidenceRegionsANDROID" type="enum"> + <enum value="0" name="XR_FACE_CONFIDENCE_REGIONS_LOWER_ANDROID" comment="Confidence corresponding to the lower region."/> + <enum value="1" name="XR_FACE_CONFIDENCE_REGIONS_LEFT_UPPER_ANDROID" comment="Confidence corresponding to the left upper region."/> + <enum value="2" name="XR_FACE_CONFIDENCE_REGIONS_RIGHT_UPPER_ANDROID" comment="Confidence corresponding to the right upper region."/> + </enums> + + <!-- enums for XR_ANDROID_passthrough_camera_state--> + <enums name="XrPassthroughCameraStateANDROID" type="enum"> + <enum value="0" name="XR_PASSTHROUGH_CAMERA_STATE_DISABLED_ANDROID" comment="The camera has been disabled by an app, the system or the user."/> + <enum value="1" name="XR_PASSTHROUGH_CAMERA_STATE_INITIALIZING_ANDROID" comment="The camera is still coming online and not yet ready to use. The runtime may: render a black background where the passthrough video is supposed to appear."/> + <enum value="2" name="XR_PASSTHROUGH_CAMERA_STATE_READY_ANDROID" comment="The camera is ready to use."/> + <enum value="3" name="XR_PASSTHROUGH_CAMERA_STATE_ERROR_ANDROID" comment="The camera is in an unrecoverable error state."/> + </enums> + + <!-- enums for XR_ANDROID_trackables_object --> + <enums name="XrObjectLabelANDROID" type="enum"> + <enum value="0" name="XR_OBJECT_LABEL_UNKNOWN_ANDROID" comment="It was not possible to label the object."/> + <enum value="1" name="XR_OBJECT_LABEL_KEYBOARD_ANDROID" comment="The object is a keyboard."/> + <enum value="2" name="XR_OBJECT_LABEL_MOUSE_ANDROID" comment="The object is a mouse."/> + <enum value="3" name="XR_OBJECT_LABEL_LAPTOP_ANDROID" comment="The object is a laptop."/> + </enums> + + <!-- enums for XR_ANDROID_trackables_marker --> + <enums name="XrTrackableMarkerTrackingModeANDROID" type="enum"> + <enum value="0" name="XR_TRACKABLE_MARKER_TRACKING_MODE_DYNAMIC_ANDROID" comment="Tracking dynamic markers. This mode has the highest accuracy and works on moving and static markers, but also has the highest power consumption."/> + <enum value="1" name="XR_TRACKABLE_MARKER_TRACKING_MODE_STATIC_ANDROID" comment="Tracking static markers. This mode is primarily useful for markers that are known to be static, which leads to less power consumption in comparison to the dynamic mode."/> + </enums> + <enums name="XrTrackableMarkerDictionaryANDROID" type="enum"> + <enum value="0" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_50_ANDROID"/> + <enum value="1" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_100_ANDROID"/> + <enum value="2" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_250_ANDROID"/> + <enum value="3" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_1000_ANDROID"/> + <enum value="4" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_50_ANDROID"/> + <enum value="5" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_100_ANDROID"/> + <enum value="6" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_250_ANDROID"/> + <enum value="7" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_1000_ANDROID"/> + <enum value="8" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_50_ANDROID"/> + <enum value="9" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_100_ANDROID"/> + <enum value="10" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_250_ANDROID"/> + <enum value="11" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_1000_ANDROID"/> + <enum value="12" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_50_ANDROID"/> + <enum value="13" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_100_ANDROID"/> + <enum value="14" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_250_ANDROID"/> + <enum value="15" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_1000_ANDROID"/> + <enum value="16" name="XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_16H5_ANDROID"/> + <enum value="17" name="XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_25H9_ANDROID"/> + <enum value="18" name="XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_36H10_ANDROID"/> + <enum value="19" name="XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_36H11_ANDROID"/> + </enums> + + <!-- enums for XR_ANDROID_device_anchor_persistence --> + <enums name="XrAnchorPersistStateANDROID" type="enum"> + <enum value="0" name="XR_ANCHOR_PERSIST_STATE_PERSIST_NOT_REQUESTED_ANDROID" comment="Anchor has not been requested to be persisted by the app."/> + <enum value="1" name="XR_ANCHOR_PERSIST_STATE_PERSIST_PENDING_ANDROID" comment="Anchor has been requested to be persisted but not persisted yet."/> + <enum value="2" name="XR_ANCHOR_PERSIST_STATE_PERSISTED_ANDROID" comment="Anchor has been successfully persisted by the runtime."/> + </enums> + + <!-- enums for XR_ANDROID_trackables_qr_code --> + <enums name="XrQrCodeTrackingModeANDROID" type="enum"> + <enum value="0" name="XR_QR_CODE_TRACKING_MODE_DYNAMIC_ANDROID" comment="Tracking dynamic QR codes. This mode has the highest accuracy and works on moving and static QR codes, but also has the highest power consumption."/> + <enum value="1" name="XR_QR_CODE_TRACKING_MODE_STATIC_ANDROID" comment="Tracking static QR codes. This mode is primarily useful for QR codes that are known to be static, which leads to less power consumption in comparison to the dynamic mode."/> + </enums> + + <!-- enums for XR_ANDROID_composition_layer_passthrough_mesh --> + <enums name="XrWindingOrderANDROID" type="enum"> + <enum value="0" name="XR_WINDING_ORDER_UNKNOWN_ANDROID" comment="Winding order of the mesh's triangles is not known."/> + <enum value="1" name="XR_WINDING_ORDER_CW_ANDROID" comment="Winding order of the mesh's triangles is clockwise."/> + <enum value="2" name="XR_WINDING_ORDER_CCW_ANDROID" comment="Winding order of the mesh's triangles is counter-clockwise."/> + </enums> + + <!-- enums for XR_ANDROID_scene_meshing --> + <enums name="XrSceneMeshSemanticLabelSetANDROID" type="enum"> + <enum value="0" name="XR_SCENE_MESH_SEMANTIC_LABEL_SET_NONE_ANDROID" comment="This semantic label set represents absence of semantic labels."/> + <enum value="1" name="XR_SCENE_MESH_SEMANTIC_LABEL_SET_DEFAULT_ANDROID" comment="This semantic label set represents XrSceneMeshSemanticLabelANDROID."/> + </enums> + <enums name="XrSceneMeshSemanticLabelANDROID" type="enum"> + <enum value="0" name="XR_SCENE_MESH_SEMANTIC_LABEL_OTHER_ANDROID" comment="This semantic label indicates that the corresponding mesh element represents an unknown object."/> + <enum value="1" name="XR_SCENE_MESH_SEMANTIC_LABEL_FLOOR_ANDROID" comment="This semantic label indicates that the corresponding mesh element represents a floor."/> + <enum value="2" name="XR_SCENE_MESH_SEMANTIC_LABEL_CEILING_ANDROID" comment="This semantic label indicates that the corresponding mesh element represents a ceiling."/> + <enum value="3" name="XR_SCENE_MESH_SEMANTIC_LABEL_WALL_ANDROID" comment="This semantic label indicates that the corresponding mesh element represents a wall."/> + <enum value="4" name="XR_SCENE_MESH_SEMANTIC_LABEL_TABLE_ANDROID" comment="This semantic label indicates that the corresponding mesh element represents a table."/> + </enums> + <enums name="XrSceneMeshTrackingStateANDROID" type="enum"> + <enum value="0" name="XR_SCENE_MESH_TRACKING_STATE_INITIALIZING_ANDROID" comment="The tracker is not yet ready to provide mesh data."/> + <enum value="1" name="XR_SCENE_MESH_TRACKING_STATE_TRACKING_ANDROID" comment="The tracker is actively tracking."/> + <enum value="2" name="XR_SCENE_MESH_TRACKING_STATE_WAITING_ANDROID" comment="The tracker is waiting for valid measurements to integrate since the last mesh update."/> + <enum value="3" name="XR_SCENE_MESH_TRACKING_STATE_ERROR_ANDROID" comment="The tracker has not received valid measurements for multiple cycles and is in an error state."/> + </enums> + + <!-- enums for XR_ANDROID_eye_tracking --> + <enums name="XrEyeIndexANDROID" type="enum"> + <enum value="0" name="XR_EYE_INDEX_LEFT_ANDROID" comment="Left eye."/> + <enum value="1" name="XR_EYE_INDEX_RIGHT_ANDROID" comment="Right eye."/> + </enums> + <enums name="XrEyeStateANDROID" type="enum"> + <enum value="0" name="XR_EYE_STATE_INVALID_ANDROID" comment="Indicates that the eye is in an error state or not present."/> + <enum value="1" name="XR_EYE_STATE_GAZING_ANDROID" comment="Indicates that the eye is currently gazing."/> + <enum value="2" name="XR_EYE_STATE_SHUT_ANDROID" comment="Indicates that the eye is currently shut due to a wink or a blink."/> + </enums> + <enums name="XrEyeTrackingModeANDROID" type="enum"> + <enum value="0" name="XR_EYE_TRACKING_MODE_NOT_TRACKING_ANDROID" comment="Indicates that eye tracking is not currently active."/> + <enum value="1" name="XR_EYE_TRACKING_MODE_RIGHT_ANDROID" comment="Indicates that only the right eye is tracking."/> + <enum value="2" name="XR_EYE_TRACKING_MODE_LEFT_ANDROID" comment="Indicates that only the left eye is tracking."/> + <enum value="3" name="XR_EYE_TRACKING_MODE_BOTH_ANDROID" comment="Indicates that both the left and right eyes are tracking."/> + </enums> + + <!-- enums for XR_ML_frame_end_info --> + <enums name="XrFrameEndInfoFlagBitsML" type="bitmask"> + <enum bitpos="0" name="XR_FRAME_END_INFO_PROTECTED_BIT_ML" comment="Indicates that the content for this frame is protected and should not be recorded or captured outside the graphics system."/> + <enum bitpos="1" name="XR_FRAME_END_INFO_VIGNETTE_BIT_ML" comment="Indicates that a soft fade to transparent should be added to the frame in the compositor to blend any hard edges at the FOV limits."/> + </enums> + + <!-- enums for XR_ML_global_dimmer --> + <enums name="XrGlobalDimmerFrameEndInfoFlagBitsML" type="bitmask"> + <enum bitpos="0" name="XR_GLOBAL_DIMMER_FRAME_END_INFO_ENABLED_BIT_ML" comment="Indicates that the global dimmer should: be enabled and controlled by slink:XrGlobalDimmerFrameEndInfoML::pname:dimmerValue."/> + </enums> + + <!-- enums for XR_QCOM_tracking_optimization_settings --> + <enums name="XrTrackingOptimizationSettingsHintQCOM" type="enum"> + <enum value="0" name="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_NONE_QCOM" comment="Used by the application to indicate that it does not have a preference to optimize for. The run-time is understood to choose a balanced approach."/> + <enum value="1" name="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LONG_RANGE_PRIORITIZATION_QCOM" comment="Used by the application to indicate that it prefers tracking to be optimized for long range, possibly at the expense of competing interests."/> + <enum value="2" name="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_CLOSE_RANGE_PRIORITIZATION_QCOM" comment="Used by the application to indicate that it prefers tracking to be optimized for close range, possibly at the expense of competing interests."/> + <enum value="3" name="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LOW_POWER_PRIORITIZATION_QCOM" comment="Used by the application to indicate that it prefers tracking to be optimized for low power consumption, possibly at the expense of competing interests."/> + <enum value="4" name="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_HIGH_POWER_PRIORITIZATION_QCOM" comment="Used by the application to indicate that it prefers tracking to be optimized for increased tracking performance, possibly at the cost of increased power consumption."/> + </enums> + + <enums name="XrTrackingOptimizationSettingsDomainQCOM" type="enum"> + <enum value="1" name="XR_TRACKING_OPTIMIZATION_SETTINGS_DOMAIN_ALL_QCOM" comment="Setting applies to all QCOM tracking extensions."/> + </enums> + + <!-- enums for XR_MNDX_force_feedback_curl --> + <enums name="XrForceFeedbackCurlLocationMNDX" type="enum"> + <enum value="0" name="XR_FORCE_FEEDBACK_CURL_LOCATION_THUMB_CURL_MNDX" comment="force feedback for thumb curl"/> + <enum value="1" name="XR_FORCE_FEEDBACK_CURL_LOCATION_INDEX_CURL_MNDX" comment="force feedback for index finger curl"/> + <enum value="2" name="XR_FORCE_FEEDBACK_CURL_LOCATION_MIDDLE_CURL_MNDX" comment="force feedback for middle finger curl"/> + <enum value="3" name="XR_FORCE_FEEDBACK_CURL_LOCATION_RING_CURL_MNDX" comment="force feedback for ring finger curl"/> + <enum value="4" name="XR_FORCE_FEEDBACK_CURL_LOCATION_LITTLE_CURL_MNDX" comment="force feedback for little finger curl"/> + </enums> + + <!-- enums XR_EXT_plane_detection --> + <enums name="XrPlaneDetectorFlagBitsEXT" type="bitmask"> + <enum bitpos="0" name="XR_PLANE_DETECTOR_ENABLE_CONTOUR_BIT_EXT" comment="populate the plane contour information"/> + </enums> + + <enums name="XrPlaneDetectionCapabilityFlagBitsEXT" type="bitmask"> + <enum bitpos="0" name="XR_PLANE_DETECTION_CAPABILITY_PLANE_DETECTION_BIT_EXT" comment="plane detection is supported"/> + <enum bitpos="1" name="XR_PLANE_DETECTION_CAPABILITY_PLANE_HOLES_BIT_EXT" comment="polygon buffers for holes in planes can be generated"/> + <enum bitpos="2" name="XR_PLANE_DETECTION_CAPABILITY_SEMANTIC_CEILING_BIT_EXT" comment="plane detection supports ceiling semantic classification"/> + <enum bitpos="3" name="XR_PLANE_DETECTION_CAPABILITY_SEMANTIC_FLOOR_BIT_EXT" comment="plane detection supports floor semantic classification"/> + <enum bitpos="4" name="XR_PLANE_DETECTION_CAPABILITY_SEMANTIC_WALL_BIT_EXT" comment="plane detection supports wall semantic classification"/> + <enum bitpos="5" name="XR_PLANE_DETECTION_CAPABILITY_SEMANTIC_PLATFORM_BIT_EXT" comment="plane detection supports platform semantic classification (for example table tops)"/> + <enum bitpos="6" name="XR_PLANE_DETECTION_CAPABILITY_ORIENTATION_BIT_EXT" comment="plane detection supports plane orientation classification. If not supported planes are always classified as ARBITRARY."/> + </enums> + + <enums name="XrPlaneDetectionStateEXT" type="enum"> + <enum value="0" name="XR_PLANE_DETECTION_STATE_NONE_EXT"/> + <enum value="1" name="XR_PLANE_DETECTION_STATE_PENDING_EXT"/> + <enum value="2" name="XR_PLANE_DETECTION_STATE_DONE_EXT"/> + <enum value="3" name="XR_PLANE_DETECTION_STATE_ERROR_EXT"/> + <enum value="4" name="XR_PLANE_DETECTION_STATE_FATAL_EXT"/> + </enums> + + <enums name="XrPlaneDetectorOrientationEXT" type="enum"> + <enum value="0" name="XR_PLANE_DETECTOR_ORIENTATION_HORIZONTAL_UPWARD_EXT" comment="The detected plane is horizontal and faces upward (e.g. floor)."/> + <enum value="1" name="XR_PLANE_DETECTOR_ORIENTATION_HORIZONTAL_DOWNWARD_EXT" comment="The detected plane is horizontal and faces downward (e.g. ceiling)."/> + <enum value="2" name="XR_PLANE_DETECTOR_ORIENTATION_VERTICAL_EXT" comment="The detected plane is vertical (e.g. wall)."/> + <enum value="3" name="XR_PLANE_DETECTOR_ORIENTATION_ARBITRARY_EXT" comment="The detected plane has an arbitrary, non-vertical and non-horizontal orientation."/> + </enums> + + <enums name="XrPlaneDetectorSemanticTypeEXT" type="enum"> + <enum value="0" name="XR_PLANE_DETECTOR_SEMANTIC_TYPE_UNDEFINED_EXT" comment="The runtime was unable to classify this plane."/> + <enum value="1" name="XR_PLANE_DETECTOR_SEMANTIC_TYPE_CEILING_EXT" comment="The detected plane is a ceiling."/> + <enum value="2" name="XR_PLANE_DETECTOR_SEMANTIC_TYPE_FLOOR_EXT" comment="The detected plane is a floor."/> + <enum value="3" name="XR_PLANE_DETECTOR_SEMANTIC_TYPE_WALL_EXT" comment="The detected plane is a wall."/> + <enum value="4" name="XR_PLANE_DETECTOR_SEMANTIC_TYPE_PLATFORM_EXT" comment="The detected plane is a platform, like a table."/> + </enums> + + <!-- enums for XR_META_virtual_keyboard --> + <enums name="XrVirtualKeyboardLocationTypeMETA" type="enum"> + <enum value="0" name="XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_CUSTOM_META" comment="Indicates that the application will provide the position and scale of the keyboard."/> + <enum value="1" name="XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_FAR_META" comment="Indicates that the runtime will set the position and scale for far field keyboard."/> + <enum value="2" name="XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_DIRECT_META" comment="Indicates that the runtime will set the position and scale for direct interaction keyboard."/> + </enums> + + <enums name="XrVirtualKeyboardInputSourceMETA" type="enum"> + <enum value="1" name="XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_RAY_LEFT_META" comment="Left controller ray."/> + <enum value="2" name="XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_RAY_RIGHT_META" comment="Right controller ray."/> + <enum value="3" name="XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_RAY_LEFT_META" comment="Left hand ray."/> + <enum value="4" name="XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_RAY_RIGHT_META" comment="Right hand ray."/> + <enum value="5" name="XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_DIRECT_LEFT_META" comment="Left controller direct touch."/> + <enum value="6" name="XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_DIRECT_RIGHT_META" comment="Right controller direct touch."/> + <enum value="7" name="XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_DIRECT_INDEX_TIP_LEFT_META" comment="Left hand direct touch."/> + <enum value="8" name="XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_DIRECT_INDEX_TIP_RIGHT_META" comment="Right hand direct touch."/> + </enums> + + <enums name="XrVirtualKeyboardInputStateFlagBitsMETA" type="bitmask"> + <enum bitpos="0" name="XR_VIRTUAL_KEYBOARD_INPUT_STATE_PRESSED_BIT_META" comment="If the input source is considered 'pressed' at all. Pinch for hands, Primary button for controllers."/> + </enums> + + <!-- XR_ML_user_calibration --> + <enums name="XrHeadsetFitStatusML" type="enum"> + <enum value="0" name="XR_HEADSET_FIT_STATUS_UNKNOWN_ML" comment="Headset fit status not available for unknown reason."/> + <enum value="1" name="XR_HEADSET_FIT_STATUS_NOT_WORN_ML" comment="Headset not worn."/> + <enum value="2" name="XR_HEADSET_FIT_STATUS_GOOD_FIT_ML" comment="Good fit."/> + <enum value="3" name="XR_HEADSET_FIT_STATUS_BAD_FIT_ML" comment="Bad fit."/> + </enums> + + <enums name="XrEyeCalibrationStatusML" type="enum"> + <enum value="0" name="XR_EYE_CALIBRATION_STATUS_UNKNOWN_ML" comment="Eye calibration status not available for unknown reason."/> + <enum value="1" name="XR_EYE_CALIBRATION_STATUS_NONE_ML" comment="User has not performed the eye calibration step. Use system provided app to perform eye calibration."/> + <enum value="2" name="XR_EYE_CALIBRATION_STATUS_COARSE_ML" comment="Eye calibration is of lower accuracy."/> + <enum value="3" name="XR_EYE_CALIBRATION_STATUS_FINE_ML" comment="Eye calibration is of higher accuracy."/> + </enums> + + <!-- XR_ML_localization_map --> + <enums name="XrLocalizationMapStateML" type="enum"> + <enum value="0" name="XR_LOCALIZATION_MAP_STATE_NOT_LOCALIZED_ML" comment="The system is not localized into a map. Features like Spatial Anchors relying on localization will not work."/> + <enum value="1" name="XR_LOCALIZATION_MAP_STATE_LOCALIZED_ML" comment="The system is localized into a map."/> + <enum value="2" name="XR_LOCALIZATION_MAP_STATE_LOCALIZATION_PENDING_ML" comment="The system is localizing into a map."/> + <enum value="3" name="XR_LOCALIZATION_MAP_STATE_LOCALIZATION_SLEEPING_BEFORE_RETRY_ML" comment="Initial localization failed, the system will retry localization."/> + </enums> + + <enums name="XrLocalizationMapTypeML" type="enum"> + <enum value="0" name="XR_LOCALIZATION_MAP_TYPE_ON_DEVICE_ML" comment="The system is localized into an On-Device map, published anchors are not shared between different devices."/> + <enum value="1" name="XR_LOCALIZATION_MAP_TYPE_CLOUD_ML" comment="The system is localized into a Cloud Map, anchors are shared per cloud account settings."/> + </enums> + + <enums name="XrLocalizationMapConfidenceML" type="enum"> + <enum value="0" name="XR_LOCALIZATION_MAP_CONFIDENCE_POOR_ML" comment="The localization map has poor confidence, systems relying on the localization map are likely to have poor performance."/> + <enum value="1" name="XR_LOCALIZATION_MAP_CONFIDENCE_FAIR_ML" comment="The confidence is fair, current environmental conditions may adversely affect localization."/> + <enum value="2" name="XR_LOCALIZATION_MAP_CONFIDENCE_GOOD_ML" comment="The confidence is high, persistent content should be stable."/> + <enum value="3" name="XR_LOCALIZATION_MAP_CONFIDENCE_EXCELLENT_ML" comment="This is a very high-confidence localization, persistent content will be very stable."/> + </enums> + + <enums name="XrLocalizationMapErrorFlagBitsML" type="bitmask"> + <enum bitpos="0" name="XR_LOCALIZATION_MAP_ERROR_UNKNOWN_BIT_ML" comment="Localization failed for an unknown reason."/> + <enum bitpos="1" name="XR_LOCALIZATION_MAP_ERROR_OUT_OF_MAPPED_AREA_BIT_ML" comment="Localization failed because the user is outside of the mapped area."/> + <enum bitpos="2" name="XR_LOCALIZATION_MAP_ERROR_LOW_FEATURE_COUNT_BIT_ML" comment="There are not enough features in the environment to successfully localize."/> + <enum bitpos="3" name="XR_LOCALIZATION_MAP_ERROR_EXCESSIVE_MOTION_BIT_ML" comment="Localization failed due to excessive motion."/> + <enum bitpos="4" name="XR_LOCALIZATION_MAP_ERROR_LOW_LIGHT_BIT_ML" comment="Localization failed because the lighting levels are too low in the environment."/> + <enum bitpos="5" name="XR_LOCALIZATION_MAP_ERROR_HEADPOSE_BIT_ML" comment="A headpose failure caused localization to be unsuccessful."/> + </enums> + + <!-- XR_ML_facial_expression --> + <enums name="XrFacialBlendShapeML" type="enum" comment="Each facial blend shape describes an area/region of a face."> + <enum value="0" name="XR_FACIAL_BLEND_SHAPE_BROW_LOWERER_L_ML"/> + <enum value="1" name="XR_FACIAL_BLEND_SHAPE_BROW_LOWERER_R_ML"/> + <enum value="2" name="XR_FACIAL_BLEND_SHAPE_CHEEK_RAISER_L_ML"/> + <enum value="3" name="XR_FACIAL_BLEND_SHAPE_CHEEK_RAISER_R_ML"/> + <enum value="4" name="XR_FACIAL_BLEND_SHAPE_CHIN_RAISER_ML"/> + <enum value="5" name="XR_FACIAL_BLEND_SHAPE_DIMPLER_L_ML"/> + <enum value="6" name="XR_FACIAL_BLEND_SHAPE_DIMPLER_R_ML"/> + <enum value="7" name="XR_FACIAL_BLEND_SHAPE_EYES_CLOSED_L_ML"/> + <enum value="8" name="XR_FACIAL_BLEND_SHAPE_EYES_CLOSED_R_ML"/> + <enum value="9" name="XR_FACIAL_BLEND_SHAPE_INNER_BROW_RAISER_L_ML"/> + <enum value="10" name="XR_FACIAL_BLEND_SHAPE_INNER_BROW_RAISER_R_ML"/> + <enum value="11" name="XR_FACIAL_BLEND_SHAPE_JAW_DROP_ML"/> + <enum value="12" name="XR_FACIAL_BLEND_SHAPE_LID_TIGHTENER_L_ML"/> + <enum value="13" name="XR_FACIAL_BLEND_SHAPE_LID_TIGHTENER_R_ML"/> + <enum value="14" name="XR_FACIAL_BLEND_SHAPE_LIP_CORNER_DEPRESSOR_L_ML"/> + <enum value="15" name="XR_FACIAL_BLEND_SHAPE_LIP_CORNER_DEPRESSOR_R_ML"/> + <enum value="16" name="XR_FACIAL_BLEND_SHAPE_LIP_CORNER_PULLER_L_ML"/> + <enum value="17" name="XR_FACIAL_BLEND_SHAPE_LIP_CORNER_PULLER_R_ML"/> + <enum value="18" name="XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_LB_ML"/> + <enum value="19" name="XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_LT_ML"/> + <enum value="20" name="XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_RB_ML"/> + <enum value="21" name="XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_RT_ML"/> + <enum value="22" name="XR_FACIAL_BLEND_SHAPE_LIP_PRESSOR_L_ML"/> + <enum value="23" name="XR_FACIAL_BLEND_SHAPE_LIP_PRESSOR_R_ML"/> + <enum value="24" name="XR_FACIAL_BLEND_SHAPE_LIP_PUCKER_L_ML"/> + <enum value="25" name="XR_FACIAL_BLEND_SHAPE_LIP_PUCKER_R_ML"/> + <enum value="26" name="XR_FACIAL_BLEND_SHAPE_LIP_STRETCHER_L_ML"/> + <enum value="27" name="XR_FACIAL_BLEND_SHAPE_LIP_STRETCHER_R_ML"/> + <enum value="28" name="XR_FACIAL_BLEND_SHAPE_LIP_SUCK_LB_ML"/> + <enum value="29" name="XR_FACIAL_BLEND_SHAPE_LIP_SUCK_LT_ML"/> + <enum value="30" name="XR_FACIAL_BLEND_SHAPE_LIP_SUCK_RB_ML"/> + <enum value="31" name="XR_FACIAL_BLEND_SHAPE_LIP_SUCK_RT_ML"/> + <enum value="32" name="XR_FACIAL_BLEND_SHAPE_LIP_TIGHTENER_L_ML"/> + <enum value="33" name="XR_FACIAL_BLEND_SHAPE_LIP_TIGHTENER_R_ML"/> + <enum value="34" name="XR_FACIAL_BLEND_SHAPE_LIPS_TOWARD_ML"/> + <enum value="35" name="XR_FACIAL_BLEND_SHAPE_LOWER_LIP_DEPRESSOR_L_ML"/> + <enum value="36" name="XR_FACIAL_BLEND_SHAPE_LOWER_LIP_DEPRESSOR_R_ML"/> + <enum value="37" name="XR_FACIAL_BLEND_SHAPE_NOSE_WRINKLER_L_ML"/> + <enum value="38" name="XR_FACIAL_BLEND_SHAPE_NOSE_WRINKLER_R_ML"/> + <enum value="39" name="XR_FACIAL_BLEND_SHAPE_OUTER_BROW_RAISER_L_ML"/> + <enum value="40" name="XR_FACIAL_BLEND_SHAPE_OUTER_BROW_RAISER_R_ML"/> + <enum value="41" name="XR_FACIAL_BLEND_SHAPE_UPPER_LID_RAISER_L_ML"/> + <enum value="42" name="XR_FACIAL_BLEND_SHAPE_UPPER_LID_RAISER_R_ML"/> + <enum value="43" name="XR_FACIAL_BLEND_SHAPE_UPPER_LIP_RAISER_L_ML"/> + <enum value="44" name="XR_FACIAL_BLEND_SHAPE_UPPER_LIP_RAISER_R_ML"/> + <enum value="45" name="XR_FACIAL_BLEND_SHAPE_TONGUE_OUT_ML"/> + </enums> + + <enums name="XrFacialExpressionBlendShapePropertiesFlagBitsML" type="bitmask"> + <enum bitpos="0" name="XR_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_VALID_BIT_ML" comment="Indicates whether the blend shape is valid."/> + <enum bitpos="1" name="XR_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_TRACKED_BIT_ML" comment="Indicates whether the blend shape is being tracked by the runtime."/> + </enums> + + <!-- XR_EXT_future --> + <enums name="XrFutureStateEXT" type="enum"> + <enum value="1" name="XR_FUTURE_STATE_PENDING_EXT"/> + <enum value="2" name="XR_FUTURE_STATE_READY_EXT"/> + </enums> + + <!-- XR_META_environment_depth --> + <enums name="XrEnvironmentDepthProviderCreateFlagBitsMETA" type="bitmask"> + <!-- This is currently empty, awaiting future flags. --> + </enums> + <enums name="XrEnvironmentDepthSwapchainCreateFlagBitsMETA" type="bitmask"> + <!-- This is currently empty, awaiting future flags. --> + </enums> + + <!-- XR_ML_spatial_anchors --> + <enums name="XrSpatialAnchorConfidenceML" type="enum"> + <enum value="0" name="XR_SPATIAL_ANCHOR_CONFIDENCE_LOW_ML" comment="Low quality, this anchor can be expected to move significantly."/> + <enum value="1" name="XR_SPATIAL_ANCHOR_CONFIDENCE_MEDIUM_ML" comment="Medium quality, this anchor may move slightly."/> + <enum value="2" name="XR_SPATIAL_ANCHOR_CONFIDENCE_HIGH_ML" comment="High quality, this anchor is stable and suitable for digital content attachment."/> + </enums> + + <!-- XR_BD_spatial_audio_rendering --> + <enums name="XrAudioSampleRateBD" type="enum"> + <enum value="1" name="XR_AUDIO_SAMPLE_RATE_192000_HZ_BD" comment="192000 Hz"/> + <enum value="2" name="XR_AUDIO_SAMPLE_RATE_96000_HZ_BD" comment="96000 Hz"/> + <enum value="3" name="XR_AUDIO_SAMPLE_RATE_48000_HZ_BD" comment="48000 Hz"/> + <enum value="4" name="XR_AUDIO_SAMPLE_RATE_44100_HZ_BD" comment="44100 Hz"/> + <enum value="5" name="XR_AUDIO_SAMPLE_RATE_32000_HZ_BD" comment="32000 Hz"/> + <enum value="6" name="XR_AUDIO_SAMPLE_RATE_24000_HZ_BD" comment="24000 Hz"/> + <enum value="7" name="XR_AUDIO_SAMPLE_RATE_22050_HZ_BD" comment="22050 Hz"/> + <enum value="8" name="XR_AUDIO_SAMPLE_RATE_16000_HZ_BD" comment="16000 Hz"/> + <enum value="9" name="XR_AUDIO_SAMPLE_RATE_12000_HZ_BD" comment="12000 Hz"/> + <enum value="10" name="XR_AUDIO_SAMPLE_RATE_11025_HZ_BD" comment="11025 Hz"/> + <enum value="11" name="XR_AUDIO_SAMPLE_RATE_8000_HZ_BD" comment="8000 Hz"/> + </enums> + + <enums name="XrAudioBufferChannelLayoutBD" type="enum"> + <enum value="0" name="XR_AUDIO_BUFFER_CHANNEL_LAYOUT_INTERLEAVED_BD" comment="indicates that audio samples from all channels are stored in an interleaved layout, where successive frames contain one sample per channel (e.g. LRLRLR for stereo)"/> + <enum value="1" name="XR_AUDIO_BUFFER_CHANNEL_LAYOUT_PLANAR_BD" comment="indicates that audio samples are stored in a planar layout, where all samples for one channel are contiguous in memory (e.g. LLL...RRR... for stereo)"/> + </enums> + + <enums name="XrSoundObstacleMaterialTypeBD" type="enum"> + <enum value="0" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_ACOUSTIC_TILE_BD" comment="indicates that the material is acoustic tile"/> + <enum value="1" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_BRICK_BD" comment="indicates that the material resembles brick"/> + <enum value="2" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_BRICK_PAINTED_BD" comment="indicates that the material resembles painted brick"/> + <enum value="3" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_CARPET_BD" comment="indicates that the material resembles carpet"/> + <enum value="4" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_CARPET_HEAVY_BD" comment="indicates that the material resembles heavy carpet"/> + <enum value="5" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_CARPET_HEAVY_PADDED_BD" comment="indicates that the material resembles heavily padded carpet"/> + <enum value="6" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_CERAMIC_TILE_BD" comment="indicates that the material resembles ceramic tile"/> + <enum value="7" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_BD" comment="indicates that the material resembles concrete"/> + <enum value="8" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_ROUGH_BD" comment="indicates that the material resembles rough concrete"/> + <enum value="9" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_BLOCK_BD" comment="indicates that the material resembles concrete block"/> + <enum value="10" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_BLOCK_PAINTED_BD" comment="indicates that the material resembles painted concrete block"/> + <enum value="11" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_CURTAIN_BD" comment="indicates that the material resembles curtain"/> + <enum value="12" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_FOLIAGE_BD" comment="indicates that the material resembles foliage"/> + <enum value="13" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_GLASS_BD" comment="indicates that the material resembles glass"/> + <enum value="14" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_GLASS_HEAVY_BD" comment="indicates that the material resembles heavy glass"/> + <enum value="15" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_GRASS_BD" comment="indicates that the material resembles grass"/> + <enum value="16" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_GRAVEL_BD" comment="indicates that the material resembles gravel"/> + <enum value="17" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_GYPSUM_BOARD_BD" comment="indicates that the material resembles gypsum board"/> + <enum value="18" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_PLASTER_ON_BRICK_BD" comment="indicates that the material resembles plaster on brick"/> + <enum value="19" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_PLASTER_ON_CONCRETE_BLOCK_BD" comment="indicates that the material resembles plaster on concrete block"/> + <enum value="20" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_SOIL_BD" comment="indicates that the material resembles soil"/> + <enum value="21" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_SOUND_PROOF_BD" comment="indicates that the material resembles sound proof"/> + <enum value="22" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_SNOW_BD" comment="indicates that the material resembles snow"/> + <enum value="23" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_STEEL_BD" comment="indicates that the material resembles steel"/> + <enum value="24" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_WATER_BD" comment="indicates that the material resembles water"/> + <enum value="25" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_THIN_BD" comment="indicates that the material resembles thin wood"/> + <enum value="26" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_THICK_BD" comment="indicates that the material resembles thick wood"/> + <enum value="27" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_FLOOR_BD" comment="indicates that the material resembles floor"/> + <enum value="28" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_ON_CONCRETE_BD" comment="indicates that the material resembles wood on concrete"/> + <enum value="29" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_CUSTOM_BD" comment="Customized material described by detailed acoustic surface parameters, for example, absorption, scattering, and transmission."/> + </enums> + + <enums name="XrSoundObjectDistanceAttenuationTypeBD" type="enum"> + <enum value="0" name="XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_NONE_BD" comment="Indicates that no attenuation is applied when source-listener distance varies."/> + <enum value="1" name="XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_INVERSE_SQUARE_BD" comment="Indicates that attenuation scales proportional to the inverse-squared distance of source-listener distance."/> + <enum value="2" name="XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_ROLLOFF_BD" comment="Indicates that attenuation equals pow(distance/refer_distance, -rolloff_factor), in which distance is clamped by minAttenuationRange and maxAttenuationRange."/> + <enum value="100" name="XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_CUSTOMIZED_BD" comment="Indicates that the distance attenuation is customized."/> + </enums> + + <enums name="XrSoundFieldChannelMaskSurroundBD" type="enum"> + <enum value="1" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_LEFT_BD" comment="Bitmask of ear-level front-left speaker"/> + <enum value="2" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_RIGHT_BD" comment="Bitmask of ear-level front-right speaker"/> + <enum value="4" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_CENTER_BD" comment="Bitmask of ear-level front-center speaker"/> + <enum value="8" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_LOW_FREQUENCY_BD" comment="Bitmask of LFE speaker"/> + <enum value="16" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_LEFT_BD" comment="Bitmask of ear-level back-left speaker"/> + <enum value="32" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_RIGHT_BD" comment="Bitmask of ear-level back-right speaker"/> + <enum value="64" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SIDE_LEFT_BD" comment="Bitmask of ear-level side-left speaker"/> + <enum value="128" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SIDE_RIGHT_BD" comment="Bitmask of ear-level side-right speaker"/> + <enum value="256" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_LEFT_BD" comment="Bitmask of height-channel front-left speaker"/> + <enum value="512" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_RIGHT_BD" comment="Bitmask of height-channel front-right speaker"/> + <enum value="1024" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_BACK_LEFT_BD" comment="Bitmask of height-channel back-left speaker"/> + <enum value="2048" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_BACK_RIGHT_BD" comment="Bitmask of height-channel back-right speaker"/> + <enum value="4096" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_CENTER_BD" comment="Bitmask of ear-level back-center speaker"/> + <enum value="8192" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_SIDE_LEFT_BD" comment="Bitmask of height-channel side-left speaker"/> + <enum value="16384" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_SIDE_RIGHT_BD" comment="Bitmask of height-channel side-right speaker"/> + <enum value="3" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_STEREO_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_LEFT_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_RIGHT_BD"/> + <enum value="11" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_2_1_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_STEREO_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_LOW_FREQUENCY_BD"/> + <enum value="7" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_3_0_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_STEREO_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_CENTER_BD"/> + <enum value="4099" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_4_0_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_3_0_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_CENTER_BD"/> + <enum value="48" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_BACK_SURROUND_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_LEFT_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_RIGHT_BD"/> + <enum value="51" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_QUAD_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_STEREO_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_BACK_SURROUND_BD"/> + <enum value="15" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_3_1_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_3_0_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_LOW_FREQUENCY_BD"/> + <enum value="55" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_0_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_3_0_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_BACK_SURROUND_BD"/> + <enum value="192" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_SIDE_SURROUND_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SIDE_LEFT_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SIDE_RIGHT_BD"/> + <enum value="199" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_0_SIDE_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_3_0_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_SIDE_SURROUND_BD"/> + <enum value="63" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_0_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_LOW_FREQUENCY_BD"/> + <enum value="207" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_SIDE_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_SIDE_SURROUND_BD"/> + <enum value="247" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_0_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_0_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_SIDE_SURROUND_BD"/> + <enum value="255" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_1_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_0_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_LOW_FREQUENCY_BD"/> + <enum value="831" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_2_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_LEFT_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_RIGHT_BD"/> + <enum value="3903" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_4_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_LEFT_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_RIGHT_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_BACK_LEFT_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_BACK_RIGHT_BD"/> + <enum value="24831" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_1_2_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_1_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_SIDE_LEFT_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_SIDE_RIGHT_BD"/> + <enum value="4095" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_1_4_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_1_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_LEFT_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_RIGHT_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_BACK_LEFT_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_BACK_RIGHT_BD"/> + </enums> + + <enums name="XrSoundFieldChannelMaskAmbixBD" type="enum"> + <enum value="1" name="XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_1ST_ORDER_BD" comment="Indicates 1st-order ambisonics in AmbiX format, which uses ACN (Ambisonic Channel Number) channel ordering and SN3D normalization"/> + <enum value="2" name="XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_2ND_ORDER_BD" comment="Indicates 2nd-order ambisonics in AmbiX format, which uses ACN (Ambisonic Channel Number) channel ordering and SN3D normalization"/> + <enum value="3" name="XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_3RD_ORDER_BD" comment="Indicates 3rd-order ambisonics in AmbiX format, which uses ACN (Ambisonic Channel Number) channel ordering and SN3D normalization"/> + <enum value="4" name="XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_4TH_ORDER_BD" comment="Indicates 4th-order ambisonics in AmbiX format, which uses ACN (Ambisonic Channel Number) channel ordering and SN3D normalization"/> + <enum value="5" name="XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_5TH_ORDER_BD" comment="Indicates 5th-order-ambisonics in AmbiX format, which uses ACN (Ambisonic Channel Number) channel ordering and SN3D normalization"/> + <enum value="6" name="XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_6TH_ORDER_BD" comment="Indicates 6th-order ambisonics in AmbiX format, which uses ACN (Ambisonic Channel Number) channel ordering and SN3D normalization"/> + <enum value="7" name="XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_7TH_ORDER_BD" comment="Indicates 7th-order ambisonics in AmbiX format, which uses ACN (Ambisonic Channel Number) channel ordering and SN3D normalization"/> + </enums> + + <enums name="XrSoundFieldChannelMaskFumaBD" type="enum"> + <enum value="1" name="XR_SOUND_FIELD_CHANNEL_MASK_FUMA_1ST_ORDER_BD" comment="Indicates the 1st-order ambisonic in FuMA format, which refers to Furse-Malham channel order and maxN normalization"/> + </enums> + + <enums name="XrSoundObstacleFlagBitsBD" type="bitmask"> + <enum bitpos="0" name="XR_SOUND_OBSTACLE_ENABLED_BIT_BD" comment="to indicate an update of slink:XrSoundObstacleConfigBD::pname:enabled"/> + <enum bitpos="1" name="XR_SOUND_OBSTACLE_POSE_BIT_BD" comment="to indicate an update of slink:XrSoundObstacleConfigBD::pname:pose"/> + <enum bitpos="2" name="XR_SOUND_OBSTACLE_MESH_BIT_BD" comment="to indicate an update of slink:XrSoundObstacleConfigBD::pname:mesh"/> + <enum bitpos="3" name="XR_SOUND_OBSTACLE_MATERIALS_BIT_BD" comment="to indicate an update of slink:XrSoundObstacleConfigBD::pname:materials"/> + </enums> + + <enums name="XrSoundObjectFlagBitsBD" type="bitmask"> + <enum bitpos="0" name="XR_SOUND_OBJECT_ENABLED_BIT_BD" comment="to indicate an update of slink:XrSoundObjectConfigBD::pname:enabled"/> + <enum bitpos="1" name="XR_SOUND_OBJECT_POSE_BIT_BD" comment="to indicate an update of slink:XrSoundObjectConfigBD::pname:pose"/> + <enum bitpos="2" name="XR_SOUND_OBJECT_DIRECTIVITY_BIT_BD" comment="to indicate an update of the directivity using an slink:XrSoundObjectDirectivityCardioidBD chained to slink:XrSoundObjectConfigBD::pname:next"/> + <enum bitpos="3" name="XR_SOUND_OBJECT_SHAPE_BIT_BD" comment="to indicate an update of the shape using an slink:XrSoundObjectShapeSphereBD chained to slink:XrSoundObjectConfigBD::pname:next"/> + <enum bitpos="4" name="XR_SOUND_OBJECT_MAIN_VOLUME_BIT_BD" comment="to indicate an update of slink:XrSoundObjectConfigBD::pname:mainVolume"/> + <enum bitpos="5" name="XR_SOUND_OBJECT_REFLECTION_GAIN_BIT_BD" comment="to indicate an update of slink:XrSoundObjectConfigBD::pname:reflectionGain"/> + <enum bitpos="6" name="XR_SOUND_OBJECT_ENABLE_DOPPLER_BIT_BD" comment="to indicate an update of slink:XrSoundObjectConfigBD::pname:enableDoppler"/> + <enum bitpos="7" name="XR_SOUND_OBJECT_DIRECT_SOUND_ATTENUATION_BIT_BD" comment="to indicate an update of slink:XrSoundObjectConfigBD::pname:directSoundAttenuation"/> + <enum bitpos="8" name="XR_SOUND_OBJECT_INDIRECT_SOUND_ATTENUATION_BIT_BD" comment="to indicate an update of slink:XrSoundObjectConfigBD::pname:indirectSoundAttenuation"/> + </enums> + + <enums name="XrSoundFieldFlagBitsBD" type="bitmask"> + <enum bitpos="0" name="XR_SOUND_FIELD_ENABLED_BIT_BD" comment="to indicate an update of slink:XrSoundFieldConfigBD::pname:enabled"/> + <enum bitpos="1" name="XR_SOUND_FIELD_ORIENTATION_BIT_BD" comment="to indicate an update of slink:XrSoundFieldConfigBD::pname:pose and/or slink:XrSoundFieldConfigBD::pname:baseSpace"/> + <enum bitpos="2" name="XR_SOUND_FIELD_MAIN_VOLUME_BIT_BD" comment="to indicate an update of slink:XrSoundFieldConfigBD::pname:mainVolume"/> + <enum bitpos="3" name="XR_SOUND_FIELD_LFE_GAIN_BIT_BD" comment="to indicate an update of slink:XrSoundFieldConfigBD::pname:lfeGain"/> + </enums> + + <!-- enums for XR_BD_spatial_sensing --> + <enums name="XrSenseDataProviderTypeBD" type="enum"> + <!-- contents from other extensions --> + </enums> + + <!-- enums for XR_BD_dynamic_object_tracking --> + <enums name="XrDynamicObjectTypeBD" type="enum"> + <enum value="0" name="XR_DYNAMIC_OBJECT_TYPE_UNKNOWN_BD" comment="Represents an unknown object type."/> + </enums> + + <enums name="XrSemanticLabelBD" type="enum"> + <enum value="0" name="XR_SEMANTIC_LABEL_UNKNOWN_BD" comment="Semantic label that the runtime does not know."/> + <enum value="1" name="XR_SEMANTIC_LABEL_FLOOR_BD" comment="Semantic label of floor."/> + <enum value="2" name="XR_SEMANTIC_LABEL_CEILING_BD" comment="Semantic label of ceiling."/> + <enum value="3" name="XR_SEMANTIC_LABEL_WALL_BD" comment="Semantic label of wall."/> + <enum value="4" name="XR_SEMANTIC_LABEL_DOOR_BD" comment="Semantic label of door."/> + <enum value="5" name="XR_SEMANTIC_LABEL_WINDOW_BD" comment="Semantic label of window."/> + <enum value="6" name="XR_SEMANTIC_LABEL_OPENING_BD" comment="Semantic label of opening, usually refers to a space that something or someone can pass through."/> + <enum value="7" name="XR_SEMANTIC_LABEL_TABLE_BD" comment="Semantic label of table."/> + <enum value="8" name="XR_SEMANTIC_LABEL_SOFA_BD" comment="Semantic label of sofa, usually refers to a seat that multiple people can sit on."/> + <enum value="9" name="XR_SEMANTIC_LABEL_CHAIR_BD" comment="Semantic label of chair, usually refers to a seat that for one person."/> + <enum value="10" name="XR_SEMANTIC_LABEL_HUMAN_BD" comment="Semantic label of human."/> + <enum value="11" name="XR_SEMANTIC_LABEL_BEAM_BD" comment="Semantic label of beam, which usually supports weight in a building or other structure."/> + <enum value="12" name="XR_SEMANTIC_LABEL_COLUMN_BD" comment="Semantic label of column, which is vertical and used as a support for the roof of a building."/> + <enum value="13" name="XR_SEMANTIC_LABEL_CURTAIN_BD" comment="Semantic label of curtain."/> + <enum value="14" name="XR_SEMANTIC_LABEL_CABINET_BD" comment="Semantic label of cabinet."/> + <enum value="15" name="XR_SEMANTIC_LABEL_BED_BD" comment="Semantic label of bed."/> + <enum value="16" name="XR_SEMANTIC_LABEL_PLANT_BD" comment="Semantic label of plant."/> + <enum value="17" name="XR_SEMANTIC_LABEL_SCREEN_BD" comment="Semantic label of screen."/> + <enum value="18" name="XR_SEMANTIC_LABEL_VIRTUAL_WALL_BD" comment="Semantic label of virtual wall, which is generated by the system scene capture app in order to create a closed space for users."/> + <enum value="19" name="XR_SEMANTIC_LABEL_REFRIGERATOR_BD" comment="Semantic label of refrigerator."/> + <enum value="20" name="XR_SEMANTIC_LABEL_WASHING_MACHINE_BD" comment="Semantic label of washing machine."/> + <enum value="21" name="XR_SEMANTIC_LABEL_AIR_CONDITIONER_BD" comment="Semantic label of air conditioner."/> + <enum value="22" name="XR_SEMANTIC_LABEL_LAMP_BD" comment="Semantic label of lamp."/> + <enum value="23" name="XR_SEMANTIC_LABEL_WALL_ART_BD" comment="Semantic label of wall art, like a painting or a photo frame."/> + <enum value="24" name="XR_SEMANTIC_LABEL_STAIRWAY_BD" comment="Semantic label of stairway."/> + <enum value="25" name="XR_SEMANTIC_LABEL_KEYBOARD_BD" comment="Semantic label of keyboard, added in extension revision 3."/> + <enum value="26" name="XR_SEMANTIC_LABEL_MOUSE_BD" comment="Semantic label of mouse, added in extension revision 3."/> + <enum value="27" name="XR_SEMANTIC_LABEL_LAPTOP_BD" comment="Semantic label of laptop, added in extension revision 3."/> + </enums> + + <enums name="XrSpatialEntityComponentTypeBD" type="enum"> + <enum value="0" name="XR_SPATIAL_ENTITY_COMPONENT_TYPE_LOCATION_BD" comment="The location including position and rotation. Corresponds to component data structure slink:XrSpatialEntityComponentDataLocationBD."/> + <enum value="1" name="XR_SPATIAL_ENTITY_COMPONENT_TYPE_SEMANTIC_BD" comment="The semantic label. Corresponds to component data structure slink:XrSpatialEntityComponentDataSemanticBD."/> + <enum value="2" name="XR_SPATIAL_ENTITY_COMPONENT_TYPE_BOUNDING_BOX_2D_BD" comment="The two-dimensional bounding box. Corresponds to component data structure slink:XrSpatialEntityComponentDataBoundingBox2DBD."/> + <enum value="3" name="XR_SPATIAL_ENTITY_COMPONENT_TYPE_POLYGON_BD" comment="The two-dimensional polygon. Corresponds to component data structure slink:XrSpatialEntityComponentDataPolygonBD."/> + <enum value="4" name="XR_SPATIAL_ENTITY_COMPONENT_TYPE_BOUNDING_BOX_3D_BD" comment="The three-dimensional bounding box. Corresponds to component data structure slink:XrSpatialEntityComponentDataBoundingBox3DBD."/> + <enum value="5" name="XR_SPATIAL_ENTITY_COMPONENT_TYPE_TRIANGLE_MESH_BD" comment="The triangle mesh. Corresponds to component data structure slink:XrSpatialEntityComponentDataTriangleMeshBD."/> + <enum value="6" name="XR_SPATIAL_ENTITY_COMPONENT_TYPE_SPHERE_BD" comment="The Sphere. Corresponds to component data structure slink:XrSpatialEntityComponentDataSphereBD."/> + </enums> + + <enums name="XrSenseDataProviderStateBD" type="enum"> + <enum value="0" name="XR_SENSE_DATA_PROVIDER_STATE_INITIALIZED_BD" comment="The state after the provider is successfully created, which means the provider is ready to start."/> + <enum value="1" name="XR_SENSE_DATA_PROVIDER_STATE_RUNNING_BD" comment="The state when the provider is running normally."/> + <enum value="2" name="XR_SENSE_DATA_PROVIDER_STATE_STOPPED_BD" comment="The state after the provider is successfully stopped, or when an unexpected error occurs."/> + </enums> + + <!-- enums for XR_BD_spatial_anchor --> + <enums name="XrPersistenceLocationBD" type="enum"> + <enum value="0" name="XR_PERSISTENCE_LOCATION_LOCAL_BD" comment="The persistence storage location is local to the device."/> + </enums> + + <!-- enums for XR_BD_spatial_mesh --> + <enums name="XrSpatialMeshLodBD" type="enum"> + <enum value="0" name="XR_SPATIAL_MESH_LOD_COARSE_BD" comment="Coarse level for the mesh with less details."/> + <enum value="1" name="XR_SPATIAL_MESH_LOD_MEDIUM_BD" comment="Medium level for the mesh."/> + <enum value="2" name="XR_SPATIAL_MESH_LOD_FINE_BD" comment="Fine level for the mesh with more details."/> + </enums> + + <enums name="XrSpatialMeshConfigFlagBitsBD" type="bitmask"> + <enum bitpos="0" name="XR_SPATIAL_MESH_CONFIG_SEMANTIC_BIT_BD" comment="Detect and include semantic label component data in the spatial entity."/> + <enum bitpos="1" name="XR_SPATIAL_MESH_CONFIG_ALIGN_SEMANTIC_WITH_VERTEX_BIT_BD" comment="Semantic labels are associated with each vertex, otherwise, semantic labels are associated with each triangle face by default. It only takes effect if ename:XR_SPATIAL_MESH_CONFIG_SEMANTIC_BIT_BD is set"/> + </enums> + + <!-- enums for XR_BD_spatial_plane --> + <enums name="XrPlaneOrientationBD" type="enum"> + <enum value="0" name="XR_PLANE_ORIENTATION_HORIZONTAL_UPWARD_BD" comment="The detected plane is horizontal and faces upward (e.g. floor)."/> + <enum value="1" name="XR_PLANE_ORIENTATION_HORIZONTAL_DOWNWARD_BD" comment="The detected plane is horizontal and faces downward (e.g. ceiling)."/> + <enum value="2" name="XR_PLANE_ORIENTATION_VERTICAL_BD" comment="The detected plane is vertical (e.g. wall)."/> + <enum value="3" name="XR_PLANE_ORIENTATION_ARBITRARY_BD" comment="The detected plane has an arbitrary, non-vertical and non-horizontal orientation."/> + </enums> + + <!-- XR_EXT_spatial_entity --> + <enums name="XrSpatialComponentTypeEXT" type="enum"> + <enum value="1" name="XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT" comment="Component that provides the 2D bounds for a spatial entity. Corresponding list structure is slink:XrSpatialComponentBounded2DListEXT; Corresponding data structure is slink:XrSpatialBounded2DDataEXT"/> + <enum value="2" name="XR_SPATIAL_COMPONENT_TYPE_BOUNDED_3D_EXT" comment="Component that provides the 3D bounds for a spatial entity. Corresponding list structure is slink:XrSpatialComponentBounded3DListEXT; Corresponding data structure is slink:XrBoxf"/> + <enum value="3" name="XR_SPATIAL_COMPONENT_TYPE_PARENT_EXT" comment="Component that provides the basetype:XrSpatialEntityIdEXT of the parent for a spatial entity. Corresponding list structure is slink:XrSpatialComponentParentListEXT; Corresponding data structure is basetype:XrSpatialEntityIdEXT"/> + <enum value="4" name="XR_SPATIAL_COMPONENT_TYPE_MESH_3D_EXT" comment="Component that provides a 3D mesh for a spatial entity. Corresponding list structure is slink:XrSpatialComponentMesh3DListEXT; Corresponding data structure is slink:XrSpatialMeshDataEXT"/> + </enums> + + <enums name="XrSpatialEntityTrackingStateEXT" type="enum"> + <enum value="1" name="XR_SPATIAL_ENTITY_TRACKING_STATE_STOPPED_EXT" comment="The runtime has stopped tracking this entity and will never resume tracking it."/> + <enum value="2" name="XR_SPATIAL_ENTITY_TRACKING_STATE_PAUSED_EXT" comment="The runtime has paused tracking this entity but may: resume tracking it in the future."/> + <enum value="3" name="XR_SPATIAL_ENTITY_TRACKING_STATE_TRACKING_EXT" comment="The runtime is currently tracking this entity and its component data is valid."/> + </enums> + + <enums name="XrSpatialCapabilityEXT" type="enum"> + </enums> + + <enums name="XrSpatialCapabilityFeatureEXT" type="enum"> + </enums> + + <enums name="XrSpatialBufferTypeEXT" type="enum"> + <enum value="0" name="XR_SPATIAL_BUFFER_TYPE_UNKNOWN_EXT"/> + <enum value="1" name="XR_SPATIAL_BUFFER_TYPE_STRING_EXT"/> + <enum value="2" name="XR_SPATIAL_BUFFER_TYPE_UINT8_EXT"/> + <enum value="3" name="XR_SPATIAL_BUFFER_TYPE_UINT16_EXT"/> + <enum value="4" name="XR_SPATIAL_BUFFER_TYPE_UINT32_EXT"/> + <enum value="5" name="XR_SPATIAL_BUFFER_TYPE_FLOAT_EXT"/> + <enum value="6" name="XR_SPATIAL_BUFFER_TYPE_VECTOR2F_EXT"/> + <enum value="7" name="XR_SPATIAL_BUFFER_TYPE_VECTOR3F_EXT"/> + </enums> + + <!-- XR_EXT_spatial_persistence --> + <enums name="XrSpatialPersistenceScopeEXT" type="enum"> + <enum value="1" name="XR_SPATIAL_PERSISTENCE_SCOPE_SYSTEM_MANAGED_EXT" comment="Provides the application with read-only access (i.e. application cannot modify the store associated with this scope) to spatial entities persisted and managed by the system. The application can: use the UUID in the persistence component for this scope to correlate entities across spatial contexts and device reboots."/> + </enums> + + <enums name="XrSpatialPersistenceContextResultEXT" type="enum"> + <!-- Return codes for successful operation execution (positive values) --> + <enum value="0" name="XR_SPATIAL_PERSISTENCE_CONTEXT_RESULT_SUCCESS_EXT" comment="The persistence context operation was a success."/> + <!-- Error codes (negative values) --> + </enums> + + <enums name="XrSpatialPersistenceStateEXT" type="enum"> + <enum value="1" name="XR_SPATIAL_PERSISTENCE_STATE_LOADED_EXT" comment="The persisted UUID has been successfully loaded from the storage."/> + <enum value="2" name="XR_SPATIAL_PERSISTENCE_STATE_NOT_FOUND_EXT" comment="The persisted UUID was not found in the storage and was either removed from it or never was in it."/> + </enums> + + <!-- XR_EXT_spatial_plane_tracking --> + <enums name="XrSpatialPlaneAlignmentEXT" type="enum"> + <enum value="0" name="XR_SPATIAL_PLANE_ALIGNMENT_HORIZONTAL_UPWARD_EXT" comment="The entity is horizontal and faces upward (e.g. floor)."/> + <enum value="1" name="XR_SPATIAL_PLANE_ALIGNMENT_HORIZONTAL_DOWNWARD_EXT" comment="The entity is horizontal and faces downward (e.g. ceiling)."/> + <enum value="2" name="XR_SPATIAL_PLANE_ALIGNMENT_VERTICAL_EXT" comment="The entity is vertical (e.g. wall)."/> + <enum value="3" name="XR_SPATIAL_PLANE_ALIGNMENT_ARBITRARY_EXT" comment="The entity has an arbitrary, non-vertical and non-horizontal orientation."/> + </enums> + + <enums name="XrSpatialPlaneSemanticLabelEXT" type="enum"> + <enum value="1" name="XR_SPATIAL_PLANE_SEMANTIC_LABEL_UNCATEGORIZED_EXT" comment="The runtime was unable to classify this entity."/> + <enum value="2" name="XR_SPATIAL_PLANE_SEMANTIC_LABEL_FLOOR_EXT" comment="The entity is a floor."/> + <enum value="3" name="XR_SPATIAL_PLANE_SEMANTIC_LABEL_WALL_EXT" comment="The entity is a wall."/> + <enum value="4" name="XR_SPATIAL_PLANE_SEMANTIC_LABEL_CEILING_EXT" comment="The entity is a ceiling."/> + <enum value="5" name="XR_SPATIAL_PLANE_SEMANTIC_LABEL_TABLE_EXT" comment="The entity is a table."/> + </enums> + + <!-- XR_EXT_spatial_marker_tracking --> + <enums name="XrSpatialMarkerArucoDictEXT" type="enum"> + <enum value="1" name="XR_SPATIAL_MARKER_ARUCO_DICT_4X4_50_EXT" comment="4 by 4 pixel Aruco marker dictionary with 50 IDs."/> + <enum value="2" name="XR_SPATIAL_MARKER_ARUCO_DICT_4X4_100_EXT" comment="4 by 4 pixel Aruco marker dictionary with 100 IDs."/> + <enum value="3" name="XR_SPATIAL_MARKER_ARUCO_DICT_4X4_250_EXT" comment="4 by 4 pixel Aruco marker dictionary with 250 IDs."/> + <enum value="4" name="XR_SPATIAL_MARKER_ARUCO_DICT_4X4_1000_EXT" comment="4 by 4 pixel Aruco marker dictionary with 1000 IDs."/> + <enum value="5" name="XR_SPATIAL_MARKER_ARUCO_DICT_5X5_50_EXT" comment="5 by 5 pixel Aruco marker dictionary with 50 IDs."/> + <enum value="6" name="XR_SPATIAL_MARKER_ARUCO_DICT_5X5_100_EXT" comment="5 by 5 pixel Aruco marker dictionary with 100 IDs."/> + <enum value="7" name="XR_SPATIAL_MARKER_ARUCO_DICT_5X5_250_EXT" comment="5 by 5 pixel Aruco marker dictionary with 250 IDs."/> + <enum value="8" name="XR_SPATIAL_MARKER_ARUCO_DICT_5X5_1000_EXT" comment="5 by 5 pixel Aruco marker dictionary with 1000 IDs."/> + <enum value="9" name="XR_SPATIAL_MARKER_ARUCO_DICT_6X6_50_EXT" comment="6 by 6 pixel Aruco marker dictionary with 50 IDs."/> + <enum value="10" name="XR_SPATIAL_MARKER_ARUCO_DICT_6X6_100_EXT" comment="6 by 6 pixel Aruco marker dictionary with 100 IDs."/> + <enum value="11" name="XR_SPATIAL_MARKER_ARUCO_DICT_6X6_250_EXT" comment="6 by 6 pixel Aruco marker dictionary with 250 IDs."/> + <enum value="12" name="XR_SPATIAL_MARKER_ARUCO_DICT_6X6_1000_EXT" comment="6 by 6 pixel Aruco marker dictionary with 1000 IDs."/> + <enum value="13" name="XR_SPATIAL_MARKER_ARUCO_DICT_7X7_50_EXT" comment="7 by 7 pixel Aruco marker dictionary with 50 IDs."/> + <enum value="14" name="XR_SPATIAL_MARKER_ARUCO_DICT_7X7_100_EXT" comment="7 by 7 pixel Aruco marker dictionary with 100 IDs."/> + <enum value="15" name="XR_SPATIAL_MARKER_ARUCO_DICT_7X7_250_EXT" comment="7 by 7 pixel Aruco marker dictionary with 250 IDs."/> + <enum value="16" name="XR_SPATIAL_MARKER_ARUCO_DICT_7X7_1000_EXT" comment="7 by 7 pixel Aruco marker dictionary with 1000 IDs."/> + </enums> + + <enums name="XrSpatialMarkerAprilTagDictEXT" type="enum"> + <enum value="1" name="XR_SPATIAL_MARKER_APRIL_TAG_DICT_16H5_EXT" comment="4 by 4 bits, minimum Hamming distance between any two codes = 5, 30 codes."/> + <enum value="2" name="XR_SPATIAL_MARKER_APRIL_TAG_DICT_25H9_EXT" comment="5 by 5 bits, minimum Hamming distance between any two codes = 9, 35 codes."/> + <enum value="3" name="XR_SPATIAL_MARKER_APRIL_TAG_DICT_36H10_EXT" comment="6 by 6 bits, minimum Hamming distance between any two codes = 10, 2320 codes."/> + <enum value="4" name="XR_SPATIAL_MARKER_APRIL_TAG_DICT_36H11_EXT" comment="6 by 6 bits, minimum Hamming distance between any two codes = 11, 587 codes."/> + </enums> + + <!-- enums for XR_BD_spatial_light_estimation --> + <enums name="XrLightEstimationCreateFlagBitsBD" type="bitmask"> + <enum bitpos="0" name="XR_LIGHT_ESTIMATION_CREATE_SPHERICAL_HARMONICS_BIT_BD" comment="Enables spherical harmonics coefficients for light estimate provider"/> + <enum bitpos="1" name="XR_LIGHT_ESTIMATION_CREATE_ENVIRONMENT_TEXTURE_BIT_BD" comment="Enables environment textures for light estimate provider"/> + </enums> + + <enums name="XrEnvironmentTextureResolutionBD" type="enum"> + <enum value="0" name="XR_ENVIRONMENT_TEXTURE_RESOLUTION_8_8_BD" comment="Environment Texture resolution of 8x8 pixels for configuring the light estimation provider."/> + <enum value="1" name="XR_ENVIRONMENT_TEXTURE_RESOLUTION_16_16_BD" comment="Environment Texture resolution of 16x16 pixels for configuring the light estimation provider."/> + <enum value="2" name="XR_ENVIRONMENT_TEXTURE_RESOLUTION_32_32_BD" comment="Environment Texture resolution of 32x32 pixels for configuring the light estimation provider."/> + <enum value="3" name="XR_ENVIRONMENT_TEXTURE_RESOLUTION_64_64_BD" comment="Environment Texture resolution of 64x64 pixels for configuring the light estimation provider."/> + <enum value="4" name="XR_ENVIRONMENT_TEXTURE_RESOLUTION_128_128_BD" comment="Environment Texture resolution of 128x128 pixels for configuring the light estimation provider."/> + </enums> + + <enums name="XrEnvironmentTextureTransferTypeBD" type="enum"> + <enum value="0" name="XR_ENVIRONMENT_TEXTURE_TRANSFER_TYPE_RAW_BD" comment="Environment Texture data transferred as raw memory buffer."/> + </enums> + + <enums name="XrEnvironmentTexturePixelFormatBD" type="enum"> + <enum value="0" name="XR_ENVIRONMENT_TEXTURE_PIXEL_FORMAT_RGB_16FLOAT_BD" comment="RGB 16-bit floating-point format for environment texture data storage with linear encoding, corresponding to GL_RGB16F in OpenGL ES."/> + <enum value="1" name="XR_ENVIRONMENT_TEXTURE_PIXEL_FORMAT_RGBA_16FLOAT_BD" comment="RGBA 16-bit floating-point format for environment texture data storage with linear encoding, corresponding to GL_RGBA16F in OpenGL ES."/> + </enums> + + <enums name="XrSphericalHarmonicsKindBD" type="enum"> + <enum value="0" name="XR_SPHERICAL_HARMONICS_KIND_TOTAL_BD" comment="The spherical harmonic coefficients represent the environment light radiance function, including the contribution from the main light."/> + </enums> + + <!-- XR_META_environment_raycast --> + <enums name="XrEnvironmentRaycastHitStatusMETA" type="enum"> + <enum value="1" name="XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_META" comment="The intersection with the environment is found."/> + <enum value="2" name="XR_ENVIRONMENT_RAYCAST_HIT_STATUS_NO_HIT_META" comment="The intersection with the environment is not found."/> + <enum value="3" name="XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_POINT_OCCLUDED_META" comment="The ray intersects with the environment, but the actual hit point is invisible."/> + <enum value="4" name="XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_POINT_OUTSIDE_OF_FOV_META" comment="The hit point can't be determined because it lies outside of the field of view."/> + <enum value="5" name="XR_ENVIRONMENT_RAYCAST_HIT_STATUS_RAY_OCCLUDED_META" comment="The ray is completely occluded by the environment."/> + <enum value="6" name="XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_INVALID_ORIENTATION_META" comment="The intersection with the environment is found, but the hit orientation cannot be determined."/> + </enums> + + <!-- XR_QCOM_hand_tracking_gesture --> + <enums name="XrHandGestureTypeQCOM" type="enum"> + <enum value="-1" name="XR_HAND_GESTURE_TYPE_UNKNOWN_QCOM" comment="Indicates that no gesture can be detected."/> + <enum value="0" name="XR_HAND_GESTURE_TYPE_OPEN_HAND_QCOM" comment="The open hand gesture is a neutral position. It is performed by extending the hand with the fingers opened and the palm away from the user."/> + <enum value="2" name="XR_HAND_GESTURE_TYPE_GRAB_QCOM" comment="The grab gesture is performed by placing the hand in front of the user and closing the hand into a fist."/> + <enum value="7" name="XR_HAND_GESTURE_TYPE_PINCH_QCOM" comment="The pinch gesture is performed by touching the tip of the thumb to the tip of the index finger while extending the remaining fingers."/> + </enums> + + <!-- XR_EXT_haptic_parametric --> + <enums name="XrHapticParametricStreamFrameTypeEXT" type="enum"> + <enum value="0" name="XR_HAPTIC_PARAMETRIC_STREAM_FRAME_TYPE_NONE_EXT"/> + <enum value="1" name="XR_HAPTIC_PARAMETRIC_STREAM_FRAME_TYPE_FIRST_FRAME_EXT"/> + <enum value="2" name="XR_HAPTIC_PARAMETRIC_STREAM_FRAME_TYPE_INTERMEDIATE_FRAME_EXT"/> + <enum value="3" name="XR_HAPTIC_PARAMETRIC_STREAM_FRAME_TYPE_LAST_FRAME_EXT"/> + </enums> + + <!-- XR_BD_camera_image --> + <enums name="XrCameraPropertyTypeBD" type="enum"> + <enum value="1" name="XR_CAMERA_PROPERTY_TYPE_FACING_BD" comment="The camera's facing orientation."/> + <enum value="2" name="XR_CAMERA_PROPERTY_TYPE_POSITION_BD" comment="The camera's position."/> + <enum value="3" name="XR_CAMERA_PROPERTY_TYPE_CAMERA_TYPE_BD" comment="The camera's type."/> + </enums> + + <enums name="XrCameraFacingBD" type="enum"> + <enum value="1" name="XR_CAMERA_FACING_WORLD_BD" comment="The camera's facing orientation is the world."/> + </enums> + + <enums name="XrCameraPositionBD" type="enum"> + <enum value="1" name="XR_CAMERA_POSITION_UNSPECIFIED_BD" comment="The camera's position is unspecified."/> + <enum value="2" name="XR_CAMERA_POSITION_LEFT_BD" comment="The camera's position is left."/> + <enum value="3" name="XR_CAMERA_POSITION_RIGHT_BD" comment="The camera's position is right."/> + </enums> + + <enums name="XrCameraTypeBD" type="enum"> + <enum value="1" name="XR_CAMERA_TYPE_PASSTHROUGH_COLOR_BD" comment="The camera is a passthrough color camera."/> + </enums> + + <enums name="XrCameraCapabilityTypeBD" type="enum"> + <enum value="1" name="XR_CAMERA_CAPABILITY_TYPE_IMAGE_RESOLUTION_AND_FRAME_RATE_BD" comment="The supported image resolutions and frame rates."/> + <enum value="2" name="XR_CAMERA_CAPABILITY_TYPE_IMAGE_FORMAT_BD" comment="The supported image formats."/> + <enum value="3" name="XR_CAMERA_CAPABILITY_TYPE_DATA_TRANSFER_TYPE_BD" comment="The supported data transfer type."/> + <enum value="4" name="XR_CAMERA_CAPABILITY_TYPE_CAMERA_MODEL_BD" comment="The supported camera models."/> + </enums> + + <enums name="XrCameraDataTransferTypeBD" type="enum"> + <enum value="1" name="XR_CAMERA_DATA_TRANSFER_TYPE_RAW_BUFFER_BD" comment="The data transfer type is raw cpu buffer."/> + </enums> + + <enums name="XrCameraImageFormatBD" type="enum"> + <enum value="1" name="XR_CAMERA_IMAGE_FORMAT_RGBA_8888_BD" comment="The image format is RGBA8888, and consecutive pixels are left to right and rows top to bottom."/> + </enums> + + <enums name="XrCameraModelBD" type="enum"> + <enum value="1" name="XR_CAMERA_MODEL_PINHOLE_BD" comment="The camera model is pinhole."/> + </enums> + + <!-- SECTION: OpenXR loader command definitions --> + <!-- openxr_loader_negotiation.h --> + <commands> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_INITIALIZATION_FAILED"> + <proto><type>XrResult</type> <name>xrNegotiateLoaderRuntimeInterface</name></proto> + <param>const <type>XrNegotiateLoaderInfo</type>* <name>loaderInfo</name></param> + <param><type>XrNegotiateRuntimeRequest</type>* <name>runtimeRequest</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_INITIALIZATION_FAILED"> + <proto><type>XrResult</type> <name>xrNegotiateLoaderApiLayerInterface</name></proto> + <param>const <type>XrNegotiateLoaderInfo</type>* <name>loaderInfo</name></param> + <param len="null-terminated">const <type>char</type>* <name>layerName</name></param> + <param><type>XrNegotiateApiLayerRequest</type>* <name>apiLayerRequest</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_INITIALIZATION_FAILED"> + <proto><type>XrResult</type> <name>xrCreateApiLayerInstance</name></proto> + <param>const <type>XrInstanceCreateInfo</type>* <name>info</name></param> + <param>const <type>XrApiLayerCreateInfo</type>* <name>layerInfo</name></param> + <param><type>XrInstance</type>* <name>instance</name></param> + </command> + </commands> + + + <!-- XR_ML_world_mesh_detection --> + <enums name="XrWorldMeshDetectorFlagBitsML" type="bitmask"> + <enum bitpos="0" name="XR_WORLD_MESH_DETECTOR_POINT_CLOUD_BIT_ML" comment="If set, will return a point cloud instead of a triangle mesh."/> + <enum bitpos="1" name="XR_WORLD_MESH_DETECTOR_COMPUTE_NORMALS_BIT_ML" comment="If set, the system will compute the normals for the triangle vertices."/> + <enum bitpos="2" name="XR_WORLD_MESH_DETECTOR_COMPUTE_CONFIDENCE_BIT_ML" comment="If set, the system will compute the confidence values."/> + <enum bitpos="3" name="XR_WORLD_MESH_DETECTOR_PLANARIZE_BIT_ML" comment="If set, the system will planarize the returned mesh (planar regions will be smoothed out)."/> + <enum bitpos="4" name="XR_WORLD_MESH_DETECTOR_REMOVE_MESH_SKIRT_BIT_ML" comment="If set, the mesh skirt (overlapping area between two mesh blocks) will be removed."/> + <enum bitpos="5" name="XR_WORLD_MESH_DETECTOR_INDEX_ORDER_CW_BIT_ML" comment="If set, winding order of indices will be be changed from counter clockwise to clockwise."/> + </enums> + + <enums name="XrWorldMeshDetectorLodML" type="enum"> + <enum value="0" name="XR_WORLD_MESH_DETECTOR_LOD_MINIMUM_ML" comment="Minimum Level of Detail (LOD) for the mesh."/> + <enum value="1" name="XR_WORLD_MESH_DETECTOR_LOD_MEDIUM_ML" comment="Medium Level of Detail (LOD) for the mesh."/> + <enum value="2" name="XR_WORLD_MESH_DETECTOR_LOD_MAXIMUM_ML" comment="Maximum Level of Detail (LOD) for the mesh."/> + </enums> + + <enums name="XrWorldMeshBlockStatusML" type="enum"> + <enum value="0" name="XR_WORLD_MESH_BLOCK_STATUS_NEW_ML" comment="The mesh block has been created."/> + <enum value="1" name="XR_WORLD_MESH_BLOCK_STATUS_UPDATED_ML" comment="The mesh block has been updated."/> + <enum value="2" name="XR_WORLD_MESH_BLOCK_STATUS_DELETED_ML" comment="The mesh block has been deleted."/> + <enum value="3" name="XR_WORLD_MESH_BLOCK_STATUS_UNCHANGED_ML" comment="The mesh block is unchanged."/> + </enums> + + <enums name="XrWorldMeshBlockResultML" type="enum"> + <enum value="0" name="XR_WORLD_MESH_BLOCK_RESULT_SUCCESS_ML" comment="Mesh request has succeeded."/> + <enum value="1" name="XR_WORLD_MESH_BLOCK_RESULT_FAILED_ML" comment="Mesh request has failed."/> + <enum value="2" name="XR_WORLD_MESH_BLOCK_RESULT_PENDING_ML" comment="Mesh request is pending."/> + <enum value="3" name="XR_WORLD_MESH_BLOCK_RESULT_PARTIAL_UPDATE_ML" comment="There are partial updates on the mesh request."/> + </enums> + + <!-- enums for XR_BD_facial_simulation --> + <enums name="XrFacialSimulationModeBD" type="enum"> + <enum value="0" name="XR_FACIAL_SIMULATION_MODE_DEFAULT_BD" comment="When calling flink:xrGetFacialSimulationDataBD, the output contains the slink:XrFacialSimulationDataBD only."/> + <enum value="1" name="XR_FACIAL_SIMULATION_MODE_COMBINED_AUDIO_BD" comment="Results in the same output as the `Default` mode, furthermore, runtime can provide a precise result by using the audio input."/> + <enum value="2" name="XR_FACIAL_SIMULATION_MODE_COMBINED_AUDIO_WITH_LIP_BD" comment="Separates the result into two parts, one is slink:XrFacialSimulationDataBD, the other is slink:XrLipExpressionDataBD."/> + <enum value="3" name="XR_FACIAL_SIMULATION_MODE_ONLY_AUDIO_WITH_LIP_BD" comment="Uses only audio input to produce the output result as slink:XrLipExpressionDataBD."/> + </enums> + + <enums name="XrFaceExpressionBD" type="enum"> + <enum value="0" name="XR_FACE_EXPRESSION_BROW_DROP_L_BD"/> + <enum value="1" name="XR_FACE_EXPRESSION_BROW_DROP_R_BD"/> + <enum value="2" name="XR_FACE_EXPRESSION_BROW_INNER_UPWARDS_BD"/> + <enum value="3" name="XR_FACE_EXPRESSION_BROW_OUTER_UPWARDS_L_BD"/> + <enum value="4" name="XR_FACE_EXPRESSION_BROW_OUTER_UPWARDS_R_BD"/> + <enum value="5" name="XR_FACE_EXPRESSION_EYE_BLINK_L_BD"/> + <enum value="6" name="XR_FACE_EXPRESSION_EYE_LOOK_DROP_L_BD"/> + <enum value="7" name="XR_FACE_EXPRESSION_EYE_LOOK_IN_L_BD"/> + <enum value="8" name="XR_FACE_EXPRESSION_EYE_LOOK_OUT_L_BD"/> + <enum value="9" name="XR_FACE_EXPRESSION_EYE_LOOK_UPWARDS_L_BD"/> + <enum value="10" name="XR_FACE_EXPRESSION_EYE_LOOK_SQUINT_L_BD"/> + <enum value="11" name="XR_FACE_EXPRESSION_EYE_LOOK_WIDE_L_BD"/> + <enum value="12" name="XR_FACE_EXPRESSION_EYE_BLINK_R_BD"/> + <enum value="13" name="XR_FACE_EXPRESSION_EYE_LOOK_DROP_R_BD"/> + <enum value="14" name="XR_FACE_EXPRESSION_EYE_LOOK_IN_R_BD"/> + <enum value="15" name="XR_FACE_EXPRESSION_EYE_LOOK_OUT_R_BD"/> + <enum value="16" name="XR_FACE_EXPRESSION_EYE_LOOK_UPWARDS_R_BD"/> + <enum value="17" name="XR_FACE_EXPRESSION_EYE_LOOK_SQUINT_R_BD"/> + <enum value="18" name="XR_FACE_EXPRESSION_EYE_LOOK_WIDE_R_BD"/> + <enum value="19" name="XR_FACE_EXPRESSION_NOSE_SNEER_L_BD"/> + <enum value="20" name="XR_FACE_EXPRESSION_NOSE_SNEER_R_BD"/> + <enum value="21" name="XR_FACE_EXPRESSION_CHEEK_PUFF_BD"/> + <enum value="22" name="XR_FACE_EXPRESSION_CHEEK_SQUINT_L_BD"/> + <enum value="23" name="XR_FACE_EXPRESSION_CHEEK_SQUINT_R_BD"/> + <enum value="24" name="XR_FACE_EXPRESSION_MOUTH_CLOSE_BD"/> + <enum value="25" name="XR_FACE_EXPRESSION_MOUTH_FUNNEL_BD"/> + <enum value="26" name="XR_FACE_EXPRESSION_MOUTH_PUCKER_BD"/> + <enum value="27" name="XR_FACE_EXPRESSION_MOUTH_L_BD"/> + <enum value="28" name="XR_FACE_EXPRESSION_MOUTH_R_BD"/> + <enum value="29" name="XR_FACE_EXPRESSION_MOUTH_SMILE_L_BD"/> + <enum value="30" name="XR_FACE_EXPRESSION_MOUTH_SMILE_R_BD"/> + <enum value="31" name="XR_FACE_EXPRESSION_MOUTH_FROWN_L_BD"/> + <enum value="32" name="XR_FACE_EXPRESSION_MOUTH_FROWN_R_BD"/> + <enum value="33" name="XR_FACE_EXPRESSION_MOUTH_DIMPLE_L_BD"/> + <enum value="34" name="XR_FACE_EXPRESSION_MOUTH_DIMPLE_R_BD"/> + <enum value="35" name="XR_FACE_EXPRESSION_MOUTH_STRETCH_L_BD"/> + <enum value="36" name="XR_FACE_EXPRESSION_MOUTH_STRETCH_R_BD"/> + <enum value="37" name="XR_FACE_EXPRESSION_MOUTH_ROLL_LOWER_BD"/> + <enum value="38" name="XR_FACE_EXPRESSION_MOUTH_ROLL_UPPER_BD"/> + <enum value="39" name="XR_FACE_EXPRESSION_MOUTH_SHRUG_LOWER_BD"/> + <enum value="40" name="XR_FACE_EXPRESSION_MOUTH_SHRUG_UPPER_BD"/> + <enum value="41" name="XR_FACE_EXPRESSION_MOUTH_PRESS_L_BD"/> + <enum value="42" name="XR_FACE_EXPRESSION_MOUTH_PRESS_R_BD"/> + <enum value="43" name="XR_FACE_EXPRESSION_MOUTH_LOWER_DROP_L_BD"/> + <enum value="44" name="XR_FACE_EXPRESSION_MOUTH_LOWER_DROP_R_BD"/> + <enum value="45" name="XR_FACE_EXPRESSION_MOUTH_UPPER_UPWARDS_L_BD"/> + <enum value="46" name="XR_FACE_EXPRESSION_MOUTH_UPPER_UPWARDS_R_BD"/> + <enum value="47" name="XR_FACE_EXPRESSION_JAW_FORWARD_BD"/> + <enum value="48" name="XR_FACE_EXPRESSION_JAW_L_BD"/> + <enum value="49" name="XR_FACE_EXPRESSION_JAW_R_BD"/> + <enum value="50" name="XR_FACE_EXPRESSION_JAW_OPEN_BD"/> + <enum value="51" name="XR_FACE_EXPRESSION_TONGUE_OUT_BD"/> + </enums> + + <enums name="XrLipExpressionBD" type="enum"> + <enum value="0" name="XR_LIP_EXPRESSION_PP_BD"/> + <enum value="1" name="XR_LIP_EXPRESSION_CH_BD"/> + <enum value="2" name="XR_LIP_EXPRESSION_LO_BD"/> + <enum value="3" name="XR_LIP_EXPRESSION_O_BD"/> + <enum value="4" name="XR_LIP_EXPRESSION_I_BD"/> + <enum value="5" name="XR_LIP_EXPRESSION_LU_BD"/> + <enum value="6" name="XR_LIP_EXPRESSION_RR_BD"/> + <enum value="7" name="XR_LIP_EXPRESSION_XX_BD"/> + <enum value="8" name="XR_LIP_EXPRESSION_LAA_BD"/> + <enum value="9" name="XR_LIP_EXPRESSION_LI_BD"/> + <enum value="10" name="XR_LIP_EXPRESSION_FF_BD"/> + <enum value="11" name="XR_LIP_EXPRESSION_U_BD"/> + <enum value="12" name="XR_LIP_EXPRESSION_TH_BD"/> + <enum value="13" name="XR_LIP_EXPRESSION_LKK_BD"/> + <enum value="14" name="XR_LIP_EXPRESSION_SS_BD"/> + <enum value="15" name="XR_LIP_EXPRESSION_LE_BD"/> + <enum value="16" name="XR_LIP_EXPRESSION_DD_BD"/> + <enum value="17" name="XR_LIP_EXPRESSION_E_BD"/> + <enum value="18" name="XR_LIP_EXPRESSION_LNN_BD"/> + <enum value="19" name="XR_LIP_EXPRESSION_SIL_BD"/> + </enums> + + <!-- XR_ANDROID_geospatial --> + <enums name="XrGeospatialTrackerStateANDROID" type="enum"> + <enum value="0" name="XR_GEOSPATIAL_TRACKER_STATE_STOPPED_ANDROID" comment="The Geospatial Tracker is not running."/> + <enum value="1" name="XR_GEOSPATIAL_TRACKER_STATE_RUNNING_ANDROID" comment="The Geospatial tracker is running and usable."/> + <enum value="2" name="XR_GEOSPATIAL_TRACKER_STATE_INITIALIZATION_FAILED_ANDROID" comment="The Geospatial Tracker failed to initialize, and will never be usable."/> + </enums> + <enums name="XrGeospatialPoseFlagBitsANDROID" type="bitmask"> + <enum bitpos="0" name="XR_GEOSPATIAL_POSE_ORIENTATION_VALID_BIT_ANDROID" comment="Indicates that the orientation member contains valid data"/> + <enum bitpos="1" name="XR_GEOSPATIAL_POSE_POSITION_VALID_BIT_ANDROID" comment="Indicates that the position member contains valid data"/> + </enums> + <enums name="XrVPSAvailabilityANDROID" type="enum"> + <enum value="1" name="XR_VPS_AVAILABILITY_UNAVAILABLE_ANDROID" comment="VPS is not available near the given location."/> + <enum value="2" name="XR_VPS_AVAILABILITY_AVAILABLE_ANDROID" comment="VPS is available near the given location."/> + </enums> + + <!-- XR_ANDROID_trackables_image --> + <enums name="XrTrackableImageFormatANDROID" type="enum"> + <enum value="1" name="XR_TRACKABLE_IMAGE_FORMAT_R8G8B8A8_ANDROID" comment="RGBA image format with 8 bits per channel color and transparency data."/> + </enums> + + <enums name="XrTrackableImageTrackingModeANDROID" type="enum"> + <enum value="1" name="XR_TRACKABLE_IMAGE_TRACKING_MODE_DYNAMIC_ANDROID" comment="This mode has the highest accuracy and allows low latency tracking of moving images. It has also has the highest power consumption."/> + <enum value="2" name="XR_TRACKABLE_IMAGE_TRACKING_MODE_STATIC_ANDROID" comment="This mode should be used for images that are known to be static or semi-static. This mode leads to less power consumption in comparison to the dynamic mode. If a static image is being moved, it will be updated with a much higher latency than using the dynamic mode."/> + </enums> + + <!-- XR_EXT_interaction_profile_battery_state_display --> + <enums name="XrBatteryStateDisplayStateFlagBitsEXT" type="bitmask"> + <enum bitpos="0" name="XR_BATTERY_STATE_DISPLAY_STATE_VALID_BIT_EXT" comment="Indicates validity of slink:XrBatteryStateDisplayEXT::pname:batteryLevel"/> + <enum bitpos="1" name="XR_BATTERY_STATE_DISPLAY_STATE_CHARGING_BIT_EXT" comment="Indicates that the device associated with the interaction profile is charging."/> + <enum bitpos="2" name="XR_BATTERY_STATE_DISPLAY_STATE_PLUGGED_IN_BIT_EXT" comment="Indicates that the device associated with the interaction profile is plugged in to a power source."/> + <enum bitpos="3" name="XR_BATTERY_STATE_DISPLAY_STATE_NO_BATTERY_BIT_EXT" comment="Indicates that the device associated with the interaction profile does not have a battery power source."/> + </enums> + + <!-- XR_ANDROID_google_cloud_auth --> + <enums name="XrGoogleCloudAuthErrorANDROID" type="enum"> + <enum value="0" name="XR_GOOGLE_CLOUD_AUTH_ERROR_NONE_ANDROID" comment="No error occurred when invoking a Google Cloud API."/> + <enum value="-1" name="XR_GOOGLE_CLOUD_AUTH_ERROR_QUOTA_EXCEEDED_ANDROID" comment="Quota exceeded when invoking a Google Cloud API."/> + <enum value="-2" name="XR_GOOGLE_CLOUD_AUTH_ERROR_UNREACHABLE_ANDROID" comment="Failed to reach a Google Cloud API, possibly due to network connectivity issues or server availability."/> + <enum value="-3" name="XR_GOOGLE_CLOUD_AUTH_ERROR_ANDROID" comment="An auth error occurred when invoking a Google Cloud API."/> + </enums> + + <!-- XR_ANDROID_geospatial_anchor --> + <enums name="XrSurfaceAnchorTypeANDROID" type="enum"> + <enum value="1" name="XR_SURFACE_ANCHOR_TYPE_TERRAIN_ANDROID" comment="Type of an anchor placed relative to the ground."/> + <enum value="2" name="XR_SURFACE_ANCHOR_TYPE_ROOFTOP_ANDROID" comment="Type of an anchor placed relative to the rooftop, or ground where there is no building."/> + </enums> + + <!-- XR_META_hand_tracking_frequency_hint --> + <enums name="XrHandTrackingFrequencyHintMETA" type="enum"> + <enum value="1" name="XR_HAND_TRACKING_FREQUENCY_HINT_DEFAULT_META"/> + <enum value="2" name="XR_HAND_TRACKING_FREQUENCY_HINT_HIGH_META"/> + </enums> + + <!-- XR_SONY_swapchain_color_space --> + <enums name="XrColorSpaceSONY" type="enum"> + <enum value="0" name="XR_COLOR_SPACE_SRGB_NONLINEAR_SONY" comment="sRGB color space, encoded according to the sRGB specification."/> + <enum value="1" name="XR_COLOR_SPACE_DISPLAY_P3_LINEAR_SONY" comment="Display-P3 color space, encoded using a linear transfer function."/> + <enum value="2" name="XR_COLOR_SPACE_DISPLAY_P3_NONLINEAR_SONY" comment="Display-P3 color space, encoded according to the Display-P3 specification."/> + <enum value="3" name="XR_COLOR_SPACE_DCI_P3_LINEAR_SONY" comment="DCI-P3 color space, encoded using a linear transfer function."/> + <enum value="4" name="XR_COLOR_SPACE_DCI_P3_NONLINEAR_SONY" comment="DCI-P3 color space, encoded according to the DCI-P3 specification."/> + <enum value="5" name="XR_COLOR_SPACE_EXTENDED_SRGB_LINEAR_SONY" comment="Extended sRGB color space, encoded using a linear transfer function."/> + <enum value="6" name="XR_COLOR_SPACE_BT709_LINEAR_SONY" comment="ITU-R BT.709 color space, encoded using a linear transfer function."/> + <enum value="7" name="XR_COLOR_SPACE_BT709_NONLINEAR_SONY" comment="ITU-R BT.709 color space, encoded according to the BT.709 specification."/> + <enum value="8" name="XR_COLOR_SPACE_BT2020_LINEAR_SONY" comment="ITU-R BT.2020 color space, encoded using a linear transfer function."/> + <enum value="9" name="XR_COLOR_SPACE_BT2020_PQ_SONY" comment="ITU-R BT.2020 color space, encoded according to the SMPTE ST 2084 Perceptual Quantizer (PQ) specification."/> + <enum value="10" name="XR_COLOR_SPACE_BT2020_HLG_SONY" comment="ITU-R BT.2020 color space, encoded according to the Hybrid Log Gamma (HLG) specification."/> + </enums> + + <!-- SECTION: OpenXR command definitions --> + <commands> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetInstanceProcAddr</name></proto> + <param optional="true"><type>XrInstance</type> <name>instance</name></param> + <param len="null-terminated">const <type>char</type>* <name>name</name></param> + <param><type>PFN_xrVoidFunction</type>* <name>function</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateApiLayerProperties</name></proto> + <param optional="true"><type>uint32_t</type> <name>propertyCapacityInput</name></param> + <param><type>uint32_t</type>* <name>propertyCountOutput</name></param> + <param optional="true" len="propertyCapacityInput"><type>XrApiLayerProperties</type>* <name>properties</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_API_LAYER_NOT_PRESENT,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_RUNTIME_UNAVAILABLE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateInstanceExtensionProperties</name></proto> + <param optional="true" len="null-terminated">const <type>char</type>* <name>layerName</name></param> + <param optional="true"><type>uint32_t</type> <name>propertyCapacityInput</name></param> + <param><type>uint32_t</type>* <name>propertyCountOutput</name></param> + <param optional="true" len="propertyCapacityInput"><type>XrExtensionProperties</type>* <name>properties</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_API_LAYER_NOT_PRESENT,XR_ERROR_API_VERSION_UNSUPPORTED,XR_ERROR_EXTENSION_DEPENDENCY_NOT_ENABLED,XR_ERROR_EXTENSION_NOT_PRESENT,XR_ERROR_INITIALIZATION_FAILED,XR_ERROR_LIMIT_REACHED,XR_ERROR_NAME_INVALID,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_RUNTIME_UNAVAILABLE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateInstance</name></proto> + <param>const <type>XrInstanceCreateInfo</type>* <name>createInfo</name></param> + <param><type>XrInstance</type>* <name>instance</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyInstance</name></proto> + <param externsync="true_with_children"><type>XrInstance</type> <name>instance</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrResultToString</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrResult</type> <name>value</name></param> + <param><type>char</type> <name>buffer</name>[<enum>XR_MAX_RESULT_STRING_SIZE</enum>]</param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStructureTypeToString</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrStructureType</type> <name>value</name></param> + <param><type>char</type> <name>buffer</name>[<enum>XR_MAX_STRUCTURE_NAME_SIZE</enum>]</param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStructureTypeToString2KHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrStructureType</type> <name>value</name></param> + <param><type>char</type> <name>buffer</name>[<enum>XR_MAX_STRUCTURE_NAME_SIZE_EXTENDED_KHR</enum>]</param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetInstanceProperties</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrInstanceProperties</type>* <name>instanceProperties</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FORM_FACTOR_UNAVAILABLE,XR_ERROR_FORM_FACTOR_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSystem</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrSystemGetInfo</type>* <name>getInfo</name></param> + <param><type>XrSystemId</type>* <name>systemId</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSystemProperties</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrSystemProperties</type>* <name>properties</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_GRAPHICS_DEVICE_INVALID,XR_ERROR_GRAPHICS_REQUIREMENTS_CALL_MISSING,XR_ERROR_HANDLE_INVALID,XR_ERROR_INITIALIZATION_FAILED,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSession</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrSessionCreateInfo</type>* <name>createInfo</name></param> + <param><type>XrSession</type>* <name>session</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySession</name></proto> + <param externsync="true_with_children"><type>XrSession</type> <name>session</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpace</name></proto> + <param externsync="true_with_children"><type>XrSpace</type> <name>space</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSwapchainFormats</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true"><type>uint32_t</type> <name>formatCapacityInput</name></param> + <param><type>uint32_t</type>* <name>formatCountOutput</name></param> + <param optional="true" len="formatCapacityInput"><type>int64_t</type>* <name>formats</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSwapchain</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSwapchainCreateInfo</type>* <name>createInfo</name></param> + <param><type>XrSwapchain</type>* <name>swapchain</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySwapchain</name></proto> + <param externsync="true_with_children"><type>XrSwapchain</type> <name>swapchain</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSwapchainImages</name></proto> + <param><type>XrSwapchain</type> <name>swapchain</name></param> + <param optional="true"><type>uint32_t</type> <name>imageCapacityInput</name></param> + <param><type>uint32_t</type>* <name>imageCountOutput</name></param> + <param optional="true" len="imageCapacityInput"><type>XrSwapchainImageBaseHeader</type>* <name>images</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrAcquireSwapchainImage</name></proto> + <param><type>XrSwapchain</type> <name>swapchain</name></param> + <param optional="true">const <type>XrSwapchainImageAcquireInfo</type>* <name>acquireInfo</name></param> + <param><type>uint32_t</type>* <name>index</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING,XR_TIMEOUT_EXPIRED" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrWaitSwapchainImage</name></proto> + <param><type>XrSwapchain</type> <name>swapchain</name></param> + <param>const <type>XrSwapchainImageWaitInfo</type>* <name>waitInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrReleaseSwapchainImage</name></proto> + <param><type>XrSwapchain</type> <name>swapchain</name></param> + <param optional="true">const <type>XrSwapchainImageReleaseInfo</type>* <name>releaseInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_READY,XR_ERROR_SESSION_RUNNING,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED"> + <proto><type>XrResult</type> <name>xrBeginSession</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSessionBeginInfo</type>* <name>beginInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_SESSION_NOT_STOPPING,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEndSession</name></proto> + <param><type>XrSession</type> <name>session</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRequestExitSession</name></proto> + <param><type>XrSession</type> <name>session</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateReferenceSpaces</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true"><type>uint32_t</type> <name>spaceCapacityInput</name></param> + <param><type>uint32_t</type>* <name>spaceCountOutput</name></param> + <param optional="true" len="spaceCapacityInput"><type>XrReferenceSpaceType</type>* <name>spaces</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_REFERENCE_SPACE_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateReferenceSpace</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrReferenceSpaceCreateInfo</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>space</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ACTION_TYPE_MISMATCH,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateActionSpace</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrActionSpaceCreateInfo</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>space</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrLocateSpace</name></proto> + <param><type>XrSpace</type> <name>space</name></param> + <param><type>XrSpace</type> <name>baseSpace</name></param> + <param><type>XrTime</type> <name>time</name></param> + <param><type>XrSpaceLocation</type>* <name>location</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateViewConfigurations</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param optional="true"><type>uint32_t</type> <name>viewConfigurationTypeCapacityInput</name></param> + <param><type>uint32_t</type>* <name>viewConfigurationTypeCountOutput</name></param> + <param optional="true" len="viewConfigurationTypeCapacityInput"><type>XrViewConfigurationType</type>* <name>viewConfigurationTypes</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED"> + <proto><type>XrResult</type> <name>xrEnumerateEnvironmentBlendModes</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></param> + <param optional="true"><type>uint32_t</type> <name>environmentBlendModeCapacityInput</name></param> + <param><type>uint32_t</type>* <name>environmentBlendModeCountOutput</name></param> + <param optional="true" len="environmentBlendModeCapacityInput"><type>XrEnvironmentBlendMode</type>* <name>environmentBlendModes</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED"> + <proto><type>XrResult</type> <name>xrGetViewConfigurationProperties</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></param> + <param><type>XrViewConfigurationProperties</type>* <name>configurationProperties</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED"> + <proto><type>XrResult</type> <name>xrEnumerateViewConfigurationViews</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></param> + <param optional="true"><type>uint32_t</type> <name>viewCapacityInput</name></param> + <param><type>uint32_t</type>* <name>viewCountOutput</name></param> + <param optional="true" len="viewCapacityInput"><type>XrViewConfigurationView</type>* <name>views</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_FRAME_DISCARDED,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrBeginFrame</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true">const <type>XrFrameBeginInfo</type>* <name>frameBeginInfo</name></param> + <implicitexternsyncparams> + <param>the pname:session parameter by any other flink:xrBeginFrame or flink:xrEndFrame call</param> + </implicitexternsyncparams> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED"> + <proto><type>XrResult</type> <name>xrLocateViews</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrViewLocateInfo</type>* <name>viewLocateInfo</name></param> + <param><type>XrViewState</type>* <name>viewState</name></param> + <param optional="true"><type>uint32_t</type> <name>viewCapacityInput</name></param> + <param><type>uint32_t</type>* <name>viewCountOutput</name></param> + <param optional="true" len="viewCapacityInput"><type>XrView</type>* <name>views</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_ENVIRONMENT_BLEND_MODE_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LAYER_INVALID,XR_ERROR_LAYER_LIMIT_EXCEEDED,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_SWAPCHAIN_RECT_INVALID,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEndFrame</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrFrameEndInfo</type>* <name>frameEndInfo</name></param> + <implicitexternsyncparams> + <param>the pname:session parameter by any other flink:xrBeginFrame or flink:xrEndFrame call</param> + </implicitexternsyncparams> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrWaitFrame</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true">const <type>XrFrameWaitInfo</type>* <name>frameWaitInfo</name></param> + <param><type>XrFrameState</type>* <name>frameState</name></param> + <implicitexternsyncparams> + <param>the pname:session parameter by any other flink:xrWaitFrame call</param> + </implicitexternsyncparams> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING,XR_SESSION_NOT_FOCUSED" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_ACTION_TYPE_MISMATCH,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrApplyHapticFeedback</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrHapticActionInfo</type>* <name>hapticActionInfo</name></param> + <param>const <type>XrHapticBaseHeader</type>* <name>hapticFeedback</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING,XR_SESSION_NOT_FOCUSED" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_ACTION_TYPE_MISMATCH,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStopHapticFeedback</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrHapticActionInfo</type>* <name>hapticActionInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_EVENT_UNAVAILABLE" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPollEvent</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrEventDataBuffer</type>* <name>eventData</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_COUNT_EXCEEDED,XR_ERROR_PATH_FORMAT_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStringToPath</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param len="null-terminated">const <type>char</type>* <name>pathString</name></param> + <param><type>XrPath</type>* <name>path</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPathToString</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrPath</type> <name>path</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>char</type>* <name>buffer</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING,XR_SPACE_BOUNDS_UNAVAILABLE" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_REFERENCE_SPACE_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetReferenceSpaceBoundsRect</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrReferenceSpaceType</type> <name>referenceSpaceType</name></param> + <param><type>XrExtent2Df</type>* <name>bounds</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ANDROID_THREAD_SETTINGS_FAILURE_KHR,XR_ERROR_ANDROID_THREAD_SETTINGS_ID_INVALID_KHR,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetAndroidApplicationThreadKHR</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrAndroidThreadTypeKHR</type> <name>threadType</name></param> + <param><type>uint32_t</type> <name>threadId</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSwapchainAndroidSurfaceKHR</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSwapchainCreateInfo</type>* <name>info</name></param> + <param><type>XrSwapchain</type>* <name>swapchain</name></param> + <param><type>jobject</type>* <name>surface</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_ACTION_TYPE_MISMATCH,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetActionStateBoolean</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrActionStateGetInfo</type>* <name>getInfo</name></param> + <param><type>XrActionStateBoolean</type>* <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_ACTION_TYPE_MISMATCH,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetActionStateFloat</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrActionStateGetInfo</type>* <name>getInfo</name></param> + <param><type>XrActionStateFloat</type>* <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_ACTION_TYPE_MISMATCH,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetActionStateVector2f</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrActionStateGetInfo</type>* <name>getInfo</name></param> + <param><type>XrActionStateVector2f</type>* <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_ACTION_TYPE_MISMATCH,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetActionStatePose</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrActionStateGetInfo</type>* <name>getInfo</name></param> + <param><type>XrActionStatePose</type>* <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_LOCALIZED_NAME_DUPLICATED,XR_ERROR_LOCALIZED_NAME_INVALID,XR_ERROR_NAME_DUPLICATED,XR_ERROR_NAME_INVALID,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PATH_FORMAT_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateActionSet</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrActionSetCreateInfo</type>* <name>createInfo</name></param> + <param><type>XrActionSet</type>* <name>actionSet</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyActionSet</name></proto> + <param externsync="true_with_children"><type>XrActionSet</type> <name>actionSet</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_ACTIONSETS_ALREADY_ATTACHED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_LOCALIZED_NAME_DUPLICATED,XR_ERROR_LOCALIZED_NAME_INVALID,XR_ERROR_NAME_DUPLICATED,XR_ERROR_NAME_INVALID,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PATH_FORMAT_INVALID,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateAction</name></proto> + <param><type>XrActionSet</type> <name>actionSet</name></param> + <param>const <type>XrActionCreateInfo</type>* <name>createInfo</name></param> + <param><type>XrAction</type>* <name>action</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyAction</name></proto> + <param externsync="true_with_children"><type>XrAction</type> <name>action</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_ACTIONSETS_ALREADY_ATTACHED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSuggestInteractionProfileBindings</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrInteractionProfileSuggestedBinding</type>* <name>suggestedBindings</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ACTIONSETS_ALREADY_ATTACHED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrAttachSessionActionSets</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSessionActionSetsAttachInfo</type>* <name>attachInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetCurrentInteractionProfile</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPath</type> <name>topLevelUserPath</name></param> + <param><type>XrInteractionProfileState</type>* <name>interactionProfile</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING,XR_SESSION_NOT_FOCUSED" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSyncActions</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrActionsSyncInfo</type>* <name>syncInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateBoundSourcesForAction</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrBoundSourcesForActionEnumerateInfo</type>* <name>enumerateInfo</name></param> + <param optional="true"><type>uint32_t</type> <name>sourceCapacityInput</name></param> + <param><type>uint32_t</type>* <name>sourceCountOutput</name></param> + <param optional="true" len="sourceCapacityInput"><type>XrPath</type>* <name>sources</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetInputSourceLocalizedName</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrInputSourceLocalizedNameGetInfo</type>* <name>getInfo</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>char</type>* <name>buffer</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetVulkanInstanceExtensionsKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>char</type>* <name>buffer</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetVulkanDeviceExtensionsKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>char</type>* <name>buffer</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetVulkanGraphicsDeviceKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>VkInstance</type> <name>vkInstance</name></param> + <param><type>VkPhysicalDevice</type>* <name>vkPhysicalDevice</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetOpenGLGraphicsRequirementsKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrGraphicsRequirementsOpenGLKHR</type>* <name>graphicsRequirements</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetOpenGLESGraphicsRequirementsKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrGraphicsRequirementsOpenGLESKHR</type>* <name>graphicsRequirements</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetVulkanGraphicsRequirementsKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrGraphicsRequirementsVulkanKHR</type>* <name>graphicsRequirements</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetD3D11GraphicsRequirementsKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrGraphicsRequirementsD3D11KHR</type>* <name>graphicsRequirements</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetD3D12GraphicsRequirementsKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrGraphicsRequirementsD3D12KHR</type>* <name>graphicsRequirements</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetMetalGraphicsRequirementsKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrGraphicsRequirementsMetalKHR</type>* <name>graphicsRequirements</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPerfSettingsSetPerformanceLevelEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPerfSettingsDomainEXT</type> <name>domain</name></param> + <param><type>XrPerfSettingsLevelEXT</type> <name>level</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrThermalGetTemperatureTrendEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPerfSettingsDomainEXT</type> <name>domain</name></param> + <param><type>XrPerfSettingsNotificationLevelEXT</type>* <name>notificationLevel</name></param> + <param><type>float</type>* <name>tempHeadroom</name></param> + <param><type>float</type>* <name>tempSlope</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetDebugUtilsObjectNameEXT</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param externsync="nameInfo.objectHandle">const <type>XrDebugUtilsObjectNameInfoEXT</type>* <name>nameInfo</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateDebugUtilsMessengerEXT</name></proto> + <param externsync="true_with_children"><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrDebugUtilsMessengerCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrDebugUtilsMessengerEXT</type>* <name>messenger</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyDebugUtilsMessengerEXT</name></proto> + <param externsync="true"><type>XrDebugUtilsMessengerEXT</type> <name>messenger</name></param> + <implicitexternsyncparams> + <param>the slink:XrInstance used to create pname:messenger, and all of its child handles</param> + </implicitexternsyncparams> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSubmitDebugUtilsMessageEXT</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrDebugUtilsMessageSeverityFlagsEXT</type> <name>messageSeverity</name></param> + <param><type>XrDebugUtilsMessageTypeFlagsEXT</type> <name>messageTypes</name></param> + <param>const <type>XrDebugUtilsMessengerCallbackDataEXT</type>* <name>callbackData</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSessionBeginDebugUtilsLabelRegionEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrDebugUtilsLabelEXT</type>* <name>labelInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSessionEndDebugUtilsLabelRegionEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSessionInsertDebugUtilsLabelEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrDebugUtilsLabelEXT</type>* <name>labelInfo</name></param> + </command> + + <!-- commands for XR_KHR_win32_convert_performance_counter_time --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrConvertTimeToWin32PerformanceCounterKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrTime</type> <name>time</name></param> + <param><type>LARGE_INTEGER</type>* <name>performanceCounter</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrConvertWin32PerformanceCounterToTimeKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>LARGE_INTEGER</type>* <name>performanceCounter</name></param> + <param><type>XrTime</type>* <name>time</name></param> + </command> + + <!-- commands for XR_KHR_vulkan_enable2 --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateVulkanInstanceKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrVulkanInstanceCreateInfoKHR</type>* <name>createInfo</name></param> + <param><type>VkInstance</type>* <name>vulkanInstance</name></param> + <param><type>VkResult</type>* <name>vulkanResult</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateVulkanDeviceKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrVulkanDeviceCreateInfoKHR</type>* <name>createInfo</name></param> + <param><type>VkDevice</type>* <name>vulkanDevice</name></param> + <param><type>VkResult</type>* <name>vulkanResult</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetVulkanGraphicsDevice2KHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrVulkanGraphicsDeviceGetInfoKHR</type>* <name>getInfo</name></param> + <param><type>VkPhysicalDevice</type>* <name>vulkanPhysicalDevice</name></param> + </command> + <command name="xrGetVulkanGraphicsRequirements2KHR" alias="xrGetVulkanGraphicsRequirementsKHR"/> + + <!-- commands for XR_KHR_convert_timespec_time --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrConvertTimeToTimespecTimeKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrTime</type> <name>time</name></param> + <param>struct <type>timespec</type>* <name>timespecTime</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrConvertTimespecTimeToTimeKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const struct <type>timespec</type>* <name>timespecTime</name></param> + <param><type>XrTime</type>* <name>time</name></param> + </command> + + <!-- commands for XR_KHR_visibility_mask --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED"> + <proto><type>XrResult</type> <name>xrGetVisibilityMaskKHR</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></param> + <param><type>uint32_t</type> <name>viewIndex</name></param> + <param><type>XrVisibilityMaskTypeKHR</type> <name>visibilityMaskType</name></param> + <param><type>XrVisibilityMaskKHR</type>* <name>visibilityMask</name></param> + </command> + + <!-- commands for XR_MSFT_spatial_anchor --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CREATE_SPATIAL_ANCHOR_FAILED_MSFT,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialAnchorCreateInfoMSFT</type>* <name>createInfo</name></param> + <param><type>XrSpatialAnchorMSFT</type>* <name>anchor</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorSpaceMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialAnchorSpaceCreateInfoMSFT</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>space</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpatialAnchorMSFT</name></proto> + <param externsync="true_with_children"><type>XrSpatialAnchorMSFT</type> <name>anchor</name></param> + </command> + + <!-- commands for XR_EXT_conformance_automation --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetInputDeviceActiveEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPath</type> <name>interactionProfile</name></param> + <param><type>XrPath</type> <name>topLevelPath</name></param> + <param><type>XrBool32</type> <name>isActive</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetInputDeviceStateBoolEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPath</type> <name>topLevelPath</name></param> + <param><type>XrPath</type> <name>inputSourcePath</name></param> + <param><type>XrBool32</type> <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetInputDeviceStateFloatEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPath</type> <name>topLevelPath</name></param> + <param><type>XrPath</type> <name>inputSourcePath</name></param> + <param><type>float</type> <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetInputDeviceStateVector2fEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPath</type> <name>topLevelPath</name></param> + <param><type>XrPath</type> <name>inputSourcePath</name></param> + <param><type>XrVector2f</type> <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetInputDeviceLocationEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPath</type> <name>topLevelPath</name></param> + <param><type>XrPath</type> <name>inputSourcePath</name></param> + <param><type>XrSpace</type> <name>space</name></param> + <param><type>XrPosef</type> <name>pose</name></param> + </command> + + <!-- commands for XR_KHR_loader_init --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrInitializeLoaderKHR</name></proto> + <param>const <type>XrLoaderInitInfoBaseHeaderKHR</type>* <name>loaderInitInfo</name></param> + </command> + + <!-- commands for XR_MSFT_spatial_graph_bridge --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialGraphNodeSpaceMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialGraphNodeSpaceCreateInfoMSFT</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>space</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrTryCreateSpatialGraphStaticNodeBindingMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialGraphStaticNodeBindingCreateInfoMSFT</type>* <name>createInfo</name></param> + <param><type>XrSpatialGraphNodeBindingMSFT</type>* <name>nodeBinding</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpatialGraphNodeBindingMSFT</name></proto> + <param externsync="true_with_children"><type>XrSpatialGraphNodeBindingMSFT</type> <name>nodeBinding</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialGraphNodeBindingPropertiesMSFT</name></proto> + <param><type>XrSpatialGraphNodeBindingMSFT</type> <name>nodeBinding</name></param> + <param optional="true">const <type>XrSpatialGraphNodeBindingPropertiesGetInfoMSFT</type>* <name>getInfo</name></param> + <param><type>XrSpatialGraphNodeBindingPropertiesMSFT</type>* <name>properties</name></param> + </command> + + <!-- XR_EXT_hand_tracking --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateHandTrackerEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrHandTrackerCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrHandTrackerEXT</type>* <name>handTracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyHandTrackerEXT</name></proto> + <param externsync="true_with_children"><type>XrHandTrackerEXT</type> <name>handTracker</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrLocateHandJointsEXT</name></proto> + <param><type>XrHandTrackerEXT</type> <name>handTracker</name></param> + <param>const <type>XrHandJointsLocateInfoEXT</type>* <name>locateInfo</name></param> + <param><type>XrHandJointLocationsEXT</type>* <name>locations</name></param> + </command> + + <!-- XR_FB_face_tracking --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateFaceTrackerFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrFaceTrackerCreateInfoFB</type>* <name>createInfo</name></param> + <param><type>XrFaceTrackerFB</type>* <name>faceTracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyFaceTrackerFB</name></proto> + <param externsync="true_with_children"><type>XrFaceTrackerFB</type> <name>faceTracker</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetFaceExpressionWeightsFB</name></proto> + <param><type>XrFaceTrackerFB</type> <name>faceTracker</name></param> + <param>const <type>XrFaceExpressionInfoFB</type>* <name>expressionInfo</name></param> + <param><type>XrFaceExpressionWeightsFB</type>* <name>expressionWeights</name></param> + </command> + + <!-- XR_FB_face_tracking2 --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateFaceTracker2FB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrFaceTrackerCreateInfo2FB</type>* <name>createInfo</name></param> + <param><type>XrFaceTracker2FB</type>* <name>faceTracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyFaceTracker2FB</name></proto> + <param externsync="true_with_children"><type>XrFaceTracker2FB</type> <name>faceTracker</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetFaceExpressionWeights2FB</name></proto> + <param><type>XrFaceTracker2FB</type> <name>faceTracker</name></param> + <param>const <type>XrFaceExpressionInfo2FB</type>* <name>expressionInfo</name></param> + <param><type>XrFaceExpressionWeights2FB</type>* <name>expressionWeights</name></param> + </command> + + <!-- XR_FB_body_tracking --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateBodyTrackerFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrBodyTrackerCreateInfoFB</type>* <name>createInfo</name></param> + <param><type>XrBodyTrackerFB</type>* <name>bodyTracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyBodyTrackerFB</name></proto> + <param externsync="true_with_children"><type>XrBodyTrackerFB</type> <name>bodyTracker</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrLocateBodyJointsFB</name></proto> + <param><type>XrBodyTrackerFB</type> <name>bodyTracker</name></param> + <param>const <type>XrBodyJointsLocateInfoFB</type>* <name>locateInfo</name></param> + <param><type>XrBodyJointLocationsFB</type>* <name>locations</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetBodySkeletonFB</name></proto> + <param><type>XrBodyTrackerFB</type> <name>bodyTracker</name></param> + <param><type>XrBodySkeletonFB</type>* <name>skeleton</name></param> + </command> + + <!-- XR_META_body_tracking_calibration --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSuggestBodyTrackingCalibrationOverrideMETA</name></proto> + <param><type>XrBodyTrackerFB</type> <name>bodyTracker</name></param> + <param>const <type>XrBodyTrackingCalibrationInfoMETA</type>* <name>calibrationInfo</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrResetBodyTrackingCalibrationMETA</name></proto> + <param><type>XrBodyTrackerFB</type> <name>bodyTracker</name></param> + </command> + + <!-- XR_FB_eye_tracking_social --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateEyeTrackerFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrEyeTrackerCreateInfoFB</type>* <name>createInfo</name></param> + <param><type>XrEyeTrackerFB</type>* <name>eyeTracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyEyeTrackerFB</name></proto> + <param externsync="true_with_children"><type>XrEyeTrackerFB</type> <name>eyeTracker</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetEyeGazesFB</name></proto> + <param><type>XrEyeTrackerFB</type> <name>eyeTracker</name></param> + <param>const <type>XrEyeGazesInfoFB</type>* <name>gazeInfo</name></param> + <param><type>XrEyeGazesFB</type>* <name>eyeGazes</name></param> + </command> + + <!-- XR_MSFT_hand_tracking_mesh --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateHandMeshSpaceMSFT</name></proto> + <param><type>XrHandTrackerEXT</type> <name>handTracker</name></param> + <param>const <type>XrHandMeshSpaceCreateInfoMSFT</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>space</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUpdateHandMeshMSFT</name></proto> + <param><type>XrHandTrackerEXT</type> <name>handTracker</name></param> + <param>const <type>XrHandMeshUpdateInfoMSFT</type>* <name>updateInfo</name></param> + <param><type>XrHandMeshMSFT</type>* <name>handMesh</name></param> + </command> + + <!-- XR_MSFT_controller_model --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CONTROLLER_MODEL_KEY_INVALID_MSFT,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetControllerModelKeyMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPath</type> <name>topLevelUserPath</name></param> + <param><type>XrControllerModelKeyStateMSFT</type>* <name>controllerModelKeyState</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CONTROLLER_MODEL_KEY_INVALID_MSFT,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrLoadControllerModelMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrControllerModelKeyMSFT</type> <name>modelKey</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>uint8_t</type>* <name>buffer</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CONTROLLER_MODEL_KEY_INVALID_MSFT,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetControllerModelPropertiesMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrControllerModelKeyMSFT</type> <name>modelKey</name></param> + <param><type>XrControllerModelPropertiesMSFT</type>* <name>properties</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CONTROLLER_MODEL_KEY_INVALID_MSFT,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetControllerModelStateMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrControllerModelKeyMSFT</type> <name>modelKey</name></param> + <param><type>XrControllerModelStateMSFT</type>* <name>state</name></param> + </command> + + <!-- XR_MSFT_scene_understanding --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSceneComputeFeaturesMSFT</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param optional="true"><type>uint32_t</type> <name>featureCapacityInput</name></param> + <param><type>uint32_t</type>* <name>featureCountOutput</name></param> + <param optional="true" len="featureCapacityInput"><type>XrSceneComputeFeatureMSFT</type>* <name>features</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSceneObserverMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true">const <type>XrSceneObserverCreateInfoMSFT</type>* <name>createInfo</name></param> + <param><type>XrSceneObserverMSFT</type>* <name>sceneObserver</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySceneObserverMSFT</name></proto> + <param externsync="true_with_children"><type>XrSceneObserverMSFT</type> <name>sceneObserver</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_COMPUTE_NEW_SCENE_NOT_COMPLETED_MSFT,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSceneMSFT</name></proto> + <param><type>XrSceneObserverMSFT</type> <name>sceneObserver</name></param> + <param optional="true">const <type>XrSceneCreateInfoMSFT</type>* <name>createInfo</name></param> + <param><type>XrSceneMSFT</type>* <name>scene</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySceneMSFT</name></proto> + <param externsync="true_with_children"><type>XrSceneMSFT</type> <name>scene</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_COMPUTE_NEW_SCENE_NOT_COMPLETED_MSFT,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SCENE_COMPUTE_CONSISTENCY_MISMATCH_MSFT,XR_ERROR_SCENE_COMPUTE_FEATURE_INCOMPATIBLE_MSFT,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrComputeNewSceneMSFT</name></proto> + <param><type>XrSceneObserverMSFT</type> <name>sceneObserver</name></param> + <param>const <type>XrNewSceneComputeInfoMSFT</type>* <name>computeInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSceneComputeStateMSFT</name></proto> + <param><type>XrSceneObserverMSFT</type> <name>sceneObserver</name></param> + <param><type>XrSceneComputeStateMSFT</type>* <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SCENE_COMPONENT_TYPE_MISMATCH_MSFT,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSceneComponentsMSFT</name></proto> + <param><type>XrSceneMSFT</type> <name>scene</name></param> + <param>const <type>XrSceneComponentsGetInfoMSFT</type>* <name>getInfo</name></param> + <param><type>XrSceneComponentsMSFT</type>* <name>components</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrLocateSceneComponentsMSFT</name></proto> + <param><type>XrSceneMSFT</type> <name>scene</name></param> + <param>const <type>XrSceneComponentsLocateInfoMSFT</type>* <name>locateInfo</name></param> + <param><type>XrSceneComponentLocationsMSFT</type>* <name>locations</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SCENE_COMPONENT_ID_INVALID_MSFT,XR_ERROR_SCENE_MESH_BUFFER_ID_INVALID_MSFT,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSceneMeshBuffersMSFT</name></proto> + <param><type>XrSceneMSFT</type> <name>scene</name></param> + <param>const <type>XrSceneMeshBuffersGetInfoMSFT</type>* <name>getInfo</name></param> + <param><type>XrSceneMeshBuffersMSFT</type>* <name>buffers</name></param> + </command> + + <!-- XR_MSFT_scene_understanding_serialization --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_COMPUTE_NEW_SCENE_NOT_COMPLETED_MSFT,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrDeserializeSceneMSFT</name></proto> + <param><type>XrSceneObserverMSFT</type> <name>sceneObserver</name></param> + <param>const <type>XrSceneDeserializeInfoMSFT</type>* <name>deserializeInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SCENE_COMPONENT_ID_INVALID_MSFT,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSerializedSceneFragmentDataMSFT</name></proto> + <param><type>XrSceneMSFT</type> <name>scene</name></param> + <param>const <type>XrSerializedSceneFragmentDataGetInfoMSFT</type>* <name>getInfo</name></param> + <param optional="true"><type>uint32_t</type> <name>countInput</name></param> + <param><type>uint32_t</type>* <name>readOutput</name></param> + <param optional="true" len="countInput"><type>uint8_t</type>* <name>buffer</name></param> + </command> + + <!-- XR_MSFT_scene_marker --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SCENE_COMPONENT_ID_INVALID_MSFT,XR_ERROR_SCENE_COMPONENT_TYPE_MISMATCH_MSFT,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSceneMarkerRawDataMSFT</name></proto> + <param><type>XrSceneMSFT</type> <name>scene</name></param> + <param>const <type>XrUuidMSFT</type>* <name>markerId</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>uint8_t</type>* <name>buffer</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SCENE_MARKER_DATA_NOT_STRING_MSFT,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SCENE_COMPONENT_ID_INVALID_MSFT,XR_ERROR_SCENE_COMPONENT_TYPE_MISMATCH_MSFT,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSceneMarkerDecodedStringMSFT</name></proto> + <param><type>XrSceneMSFT</type> <name>scene</name></param> + <param>const <type>XrUuidMSFT</type>* <name>markerId</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>char</type>* <name>buffer</name></param> + </command> + + <!-- XR_FB_display_refresh_rate --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateDisplayRefreshRatesFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true"><type>uint32_t</type> <name>displayRefreshRateCapacityInput</name></param> + <param><type>uint32_t</type>* <name>displayRefreshRateCountOutput</name></param> + <param optional="true" len="displayRefreshRateCapacityInput"><type>float</type>* <name>displayRefreshRates</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetDisplayRefreshRateFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>float</type>* <name>displayRefreshRate</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_DISPLAY_REFRESH_RATE_UNSUPPORTED_FB,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRequestDisplayRefreshRateFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>float</type> <name>displayRefreshRate</name></param> + </command> + + <!-- XR_MSFT_perception_anchor_interop --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorFromPerceptionAnchorMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>IUnknown</type>* <name>perceptionAnchor</name></param> + <param><type>XrSpatialAnchorMSFT</type>* <name>anchor</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrTryGetPerceptionAnchorFromSpatialAnchorMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrSpatialAnchorMSFT</type> <name>anchor</name></param> + <param><type>IUnknown</type>** <name>perceptionAnchor</name></param> + </command> + + <!-- XR_FB_swapchain_update_state --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUpdateSwapchainFB</name></proto> + <param><type>XrSwapchain</type> <name>swapchain</name></param> + <param>const <type>XrSwapchainStateBaseHeaderFB</type>* <name>state</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSwapchainStateFB</name></proto> + <param><type>XrSwapchain</type> <name>swapchain</name></param> + <param><type>XrSwapchainStateBaseHeaderFB</type>* <name>state</name></param> + </command> + + <!-- XR_FB_color_space --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateColorSpacesFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true"><type>uint32_t</type> <name>colorSpaceCapacityInput</name></param> + <param><type>uint32_t</type>* <name>colorSpaceCountOutput</name></param> + <param optional="true" len="colorSpaceCapacityInput"><type>XrColorSpaceFB</type>* <name>colorSpaces</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_COLOR_SPACE_UNSUPPORTED_FB,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetColorSpaceFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrColorSpaceFB</type> <name>colorSpace</name></param> + </command> + + <!-- XR_FB_foveation --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateFoveationProfileFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrFoveationProfileCreateInfoFB</type>* <name>createInfo</name></param> + <param><type>XrFoveationProfileFB</type>* <name>profile</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyFoveationProfileFB</name></proto> + <param externsync="true_with_children"><type>XrFoveationProfileFB</type> <name>profile</name></param> + </command> + + <!-- XR_META_foveation_eye_tracked --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetFoveationEyeTrackedStateMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrFoveationEyeTrackedStateMETA</type>* <name>foveationState</name></param> + </command> + + <!-- XR_FB_hand_tracking_mesh --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetHandMeshFB</name></proto> + <param><type>XrHandTrackerEXT</type> <name>handTracker</name></param> + <param><type>XrHandTrackingMeshFB</type>* <name>mesh</name></param> + </command> + + <!-- XR_FB_render_model --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateRenderModelPathsFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true"><type>uint32_t</type> <name>pathCapacityInput</name></param> + <param><type>uint32_t</type>* <name>pathCountOutput</name></param> + <param optional="true" len="pathCapacityInput"><type>XrRenderModelPathInfoFB</type>* <name>paths</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_RENDER_MODEL_UNAVAILABLE_FB,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetRenderModelPropertiesFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPath</type> <name>path</name></param> + <param><type>XrRenderModelPropertiesFB</type>* <name>properties</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_RENDER_MODEL_UNAVAILABLE_FB,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RENDER_MODEL_KEY_INVALID_FB,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrLoadRenderModelFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrRenderModelLoadInfoFB</type>* <name>info</name></param> + <param><type>XrRenderModelBufferFB</type>* <name>buffer</name></param> + </command> + + <!-- XR_FB_keyboard_tracking --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrQuerySystemTrackedKeyboardFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrKeyboardTrackingQueryFB</type>* <name>queryInfo</name></param> + <param><type>XrKeyboardTrackingDescriptionFB</type>* <name>keyboard</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateKeyboardSpaceFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrKeyboardSpaceCreateInfoFB</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>keyboardSpace</name></param> + </command> + + <!-- commands for XR_VARJO_environment_depth_estimation --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST"> + <proto><type>XrResult</type> <name>xrSetEnvironmentDepthEstimationVARJO</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrBool32</type> <name>enabled</name></param> + </command> + + <!-- XR_MSFT_composition_layer_reprojection --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED"> + <proto><type>XrResult</type> <name>xrEnumerateReprojectionModesMSFT</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></param> + <param optional="true"><type>uint32_t</type> <name>modeCapacityInput</name></param> + <param><type>uint32_t</type>* <name>modeCountOutput</name></param> + <param optional="true" len="modeCapacityInput"><type>XrReprojectionModeMSFT</type>* <name>modes</name></param> + </command> + + <!-- commands for XR_OCULUS_audio_device_guid --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetAudioOutputDeviceGuidOculus</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>wchar_t</type> <name>buffer</name>[<enum>XR_MAX_AUDIO_DEVICE_STR_SIZE_OCULUS</enum>]</param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetAudioInputDeviceGuidOculus</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>wchar_t</type> <name>buffer</name>[<enum>XR_MAX_AUDIO_DEVICE_STR_SIZE_OCULUS</enum>]</param> + </command> + + <!-- XR_FB_spatial_entity --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialAnchorCreateInfoFB</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceUuidFB</name></proto> + <param><type>XrSpace</type> <name>space</name></param> + <param><type>XrUuidEXT</type>* <name>uuid</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSpaceSupportedComponentsFB</name></proto> + <param><type>XrSpace</type> <name>space</name></param> + <param optional="true"><type>uint32_t</type> <name>componentTypeCapacityInput</name></param> + <param><type>uint32_t</type>* <name>componentTypeCountOutput</name></param> + <param optional="true" len="componentTypeCapacityInput"><type>XrSpaceComponentTypeFB</type>* <name>componentTypes</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPACE_COMPONENT_NOT_SUPPORTED_FB,XR_ERROR_SPACE_COMPONENT_STATUS_ALREADY_SET_FB,XR_ERROR_SPACE_COMPONENT_STATUS_PENDING_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetSpaceComponentStatusFB</name></proto> + <param><type>XrSpace</type> <name>space</name></param> + <param>const <type>XrSpaceComponentStatusSetInfoFB</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPACE_COMPONENT_NOT_SUPPORTED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceComponentStatusFB</name></proto> + <param><type>XrSpace</type> <name>space</name></param> + <param><type>XrSpaceComponentTypeFB</type> <name>componentType</name></param> + <param><type>XrSpaceComponentStatusFB</type>* <name>status</name></param> + </command> + + <!-- XR_FB_triangle_mesh --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_INSUFFICIENT_RESOURCES_PASSTHROUGH_FB,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateTriangleMeshFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrTriangleMeshCreateInfoFB</type>* <name>createInfo</name></param> + <param><type>XrTriangleMeshFB</type>* <name>outTriangleMesh</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyTriangleMeshFB</name></proto> + <param externsync="true_with_children"><type>XrTriangleMeshFB</type> <name>mesh</name></param> + <implicitexternsyncparams> + <param>the buffers returned from calls to flink:xrTriangleMeshGetVertexBufferFB and flink:xrTriangleMeshGetIndexBufferFB on pname:mesh</param> + </implicitexternsyncparams> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrTriangleMeshGetVertexBufferFB</name></proto> + <param><type>XrTriangleMeshFB</type> <name>mesh</name></param> + <param><type>XrVector3f</type>** <name>outVertexBuffer</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrTriangleMeshGetIndexBufferFB</name></proto> + <param><type>XrTriangleMeshFB</type> <name>mesh</name></param> + <param><type>uint32_t</type>** <name>outIndexBuffer</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrTriangleMeshBeginUpdateFB</name></proto> + <param><type>XrTriangleMeshFB</type> <name>mesh</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrTriangleMeshEndUpdateFB</name></proto> + <param><type>XrTriangleMeshFB</type> <name>mesh</name></param> + <param><type>uint32_t</type> <name>vertexCount</name></param> + <param><type>uint32_t</type> <name>triangleCount</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrTriangleMeshBeginVertexBufferUpdateFB</name></proto> + <param><type>XrTriangleMeshFB</type> <name>mesh</name></param> + <param><type>uint32_t</type>* <name>outVertexCount</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrTriangleMeshEndVertexBufferUpdateFB</name></proto> + <param><type>XrTriangleMeshFB</type> <name>mesh</name></param> + </command> + + <!-- XR_FB_passthrough --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_ALREADY_CREATED_PASSTHROUGH_FB,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_NOT_PERMITTED_PASSTHROUGH_FB,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_UNKNOWN_PASSTHROUGH_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreatePassthroughFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrPassthroughCreateInfoFB</type>* <name>createInfo</name></param> + <param><type>XrPassthroughFB</type>* <name>outPassthrough</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyPassthroughFB</name></proto> + <param externsync="true_with_children"><type>XrPassthroughFB</type> <name>passthrough</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_UNEXPECTED_STATE_PASSTHROUGH_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPassthroughStartFB</name></proto> + <param><type>XrPassthroughFB</type> <name>passthrough</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_UNEXPECTED_STATE_PASSTHROUGH_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPassthroughPauseFB</name></proto> + <param><type>XrPassthroughFB</type> <name>passthrough</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_REQUIRED_PASSTHROUGH_FB,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_INSUFFICIENT_RESOURCES_PASSTHROUGH_FB,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_UNKNOWN_PASSTHROUGH_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreatePassthroughLayerFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrPassthroughLayerCreateInfoFB</type>* <name>createInfo</name></param> + <param><type>XrPassthroughLayerFB</type>* <name>outLayer</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyPassthroughLayerFB</name></proto> + <param externsync="true_with_children"><type>XrPassthroughLayerFB</type> <name>layer</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_UNEXPECTED_STATE_PASSTHROUGH_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPassthroughLayerPauseFB</name></proto> + <param><type>XrPassthroughLayerFB</type> <name>layer</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_UNEXPECTED_STATE_PASSTHROUGH_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPassthroughLayerResumeFB</name></proto> + <param><type>XrPassthroughLayerFB</type> <name>layer</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPassthroughLayerSetStyleFB</name></proto> + <param><type>XrPassthroughLayerFB</type> <name>layer</name></param> + <param>const <type>XrPassthroughStyleFB</type>* <name>style</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_INSUFFICIENT_RESOURCES_PASSTHROUGH_FB,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateGeometryInstanceFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrGeometryInstanceCreateInfoFB</type>* <name>createInfo</name></param> + <param><type>XrGeometryInstanceFB</type>* <name>outGeometryInstance</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyGeometryInstanceFB</name></proto> + <param externsync="true_with_children"><type>XrGeometryInstanceFB</type> <name>instance</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGeometryInstanceSetTransformFB</name></proto> + <param><type>XrGeometryInstanceFB</type> <name>instance</name></param> + <param>const <type>XrGeometryInstanceTransformFB</type>* <name>transformation</name></param> + </command> + + <!-- XR_FB_spatial_entity_query --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrQuerySpacesFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpaceQueryInfoBaseHeaderFB</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRetrieveSpaceQueryResultsFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrAsyncRequestIdFB</type> <name>requestId</name></param> + <param><type>XrSpaceQueryResultsFB</type>* <name>results</name></param> + </command> + + <!-- XR_FB_spatial_entity_storage --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSaveSpaceFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpaceSaveInfoFB</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEraseSpaceFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpaceEraseInfoFB</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + + <!-- XR_FB_spatial_entity_storage_batch --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPACE_CLOUD_STORAGE_DISABLED_FB,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_SPACE_LOCALIZATION_FAILED_FB,XR_ERROR_SPACE_MAPPING_INSUFFICIENT_FB,XR_ERROR_SPACE_NETWORK_REQUEST_FAILED_FB,XR_ERROR_SPACE_NETWORK_TIMEOUT_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSaveSpaceListFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpaceListSaveInfoFB</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + + <!-- XR_FB_spatial_entity_sharing --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPACE_CLOUD_STORAGE_DISABLED_FB,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_SPACE_LOCALIZATION_FAILED_FB,XR_ERROR_SPACE_MAPPING_INSUFFICIENT_FB,XR_ERROR_SPACE_NETWORK_REQUEST_FAILED_FB,XR_ERROR_SPACE_NETWORK_TIMEOUT_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrShareSpacesFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpaceShareInfoFB</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + + <!-- XR_FB_spatial_entity_container --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceContainerFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrSpace</type> <name>space</name></param> + <param><type>XrSpaceContainerFB</type>* <name>spaceContainerOutput</name></param> + </command> + + <!-- XR_META_spatial_entity_mesh --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceTriangleMeshMETA</name></proto> + <param><type>XrSpace</type> <name>space</name></param> + <param>const <type>XrSpaceTriangleMeshGetInfoMETA</type>* <name>getInfo</name></param> + <param><type>XrSpaceTriangleMeshMETA</type>* <name>triangleMeshOutput</name></param> + </command> + + <!-- XR_META_spatial_entity_room_mesh --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceRoomMeshMETA</name></proto> + <param><type>XrSpace</type> <name>space</name></param> + <param>const <type>XrSpaceRoomMeshGetInfoMETA</type>* <name>getInfo</name></param> + <param><type>XrRoomMeshMETA</type>* <name>roomMeshOutput</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceRoomMeshFaceIndicesMETA</name></proto> + <param><type>XrSpace</type> <name>space</name></param> + <param>const <type>XrUuid</type>* <name>faceUuid</name></param> + <param><type>XrRoomMeshFaceIndicesMETA</type>* <name>roomMeshFaceIndicesOutput</name></param> + </command> + + <!-- XR_META_boundary_visibility --> + <command successcodes="XR_SUCCESS,XR_BOUNDARY_VISIBILITY_SUPPRESSION_NOT_ALLOWED_META,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRequestBoundaryVisibilityMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrBoundaryVisibilityMETA</type> <name>boundaryVisibility</name></param> + </command> + + <!-- XR_FB_scene --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceBoundingBox2DFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrSpace</type> <name>space</name></param> + <param><type>XrRect2Df</type>* <name>boundingBox2DOutput</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceBoundingBox3DFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrSpace</type> <name>space</name></param> + <param><type>XrRect3DfFB</type>* <name>boundingBox3DOutput</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceSemanticLabelsFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrSpace</type> <name>space</name></param> + <param><type>XrSemanticLabelsFB</type>* <name>semanticLabelsOutput</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceBoundary2DFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrSpace</type> <name>space</name></param> + <param><type>XrBoundary2DFB</type>* <name>boundary2DOutput</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceRoomLayoutFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrSpace</type> <name>space</name></param> + <param><type>XrRoomLayoutFB</type>* <name>roomLayoutOutput</name></param> + </command> + + <!-- XR_FB_scene_capture --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRequestSceneCaptureFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSceneCaptureRequestInfoFB</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + + <!-- XR_FB_passthrough_keyboard_hands --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPassthroughLayerSetKeyboardHandsIntensityFB</name></proto> + <param><type>XrPassthroughLayerFB</type> <name>layer</name></param> + <param>const <type>XrPassthroughKeyboardHandsIntensityFB</type>* <name>intensity</name></param> + </command> + + <!-- XR_META_colocation_discovery --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_EXTENSION_NOT_PRESENT,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_RUNTIME_UNAVAILABLE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStartColocationDiscoveryMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrColocationDiscoveryStartInfoMETA</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>discoveryRequestId</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_EXTENSION_NOT_PRESENT,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_RUNTIME_UNAVAILABLE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStopColocationDiscoveryMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrColocationDiscoveryStopInfoMETA</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_EXTENSION_NOT_PRESENT,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_RUNTIME_UNAVAILABLE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStartColocationAdvertisementMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrColocationAdvertisementStartInfoMETA</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>advertisementRequestId</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_EXTENSION_NOT_PRESENT,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_RUNTIME_UNAVAILABLE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStopColocationAdvertisementMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrColocationAdvertisementStopInfoMETA</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + + <!-- XR_META_spatial_entity_sharing --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrShareSpacesMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrShareSpacesInfoMETA</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + + <!-- XR_MSFT_spatial_anchor_persistence --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorStoreConnectionMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrSpatialAnchorStoreConnectionMSFT</type>* <name>spatialAnchorStore</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpatialAnchorStoreConnectionMSFT</name></proto> + <param externsync="true_with_children"><type>XrSpatialAnchorStoreConnectionMSFT</type> <name>spatialAnchorStore</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPersistSpatialAnchorMSFT</name></proto> + <param><type>XrSpatialAnchorStoreConnectionMSFT</type> <name>spatialAnchorStore</name></param> + <param>const <type>XrSpatialAnchorPersistenceInfoMSFT</type>* <name>spatialAnchorPersistenceInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumeratePersistedSpatialAnchorNamesMSFT</name></proto> + <param><type>XrSpatialAnchorStoreConnectionMSFT</type> <name>spatialAnchorStore</name></param> + <param optional="true"><type>uint32_t</type> <name>spatialAnchorNameCapacityInput</name></param> + <param><type>uint32_t</type>* <name>spatialAnchorNameCountOutput</name></param> + <param optional="true" len="spatialAnchorNameCapacityInput"><type>XrSpatialAnchorPersistenceNameMSFT</type>* <name>spatialAnchorNames</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT,XR_ERROR_SPATIAL_ANCHOR_NAME_NOT_FOUND_MSFT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorFromPersistedNameMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT</type>* <name>spatialAnchorCreateInfo</name></param> + <param><type>XrSpatialAnchorMSFT</type>* <name>spatialAnchor</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT,XR_ERROR_SPATIAL_ANCHOR_NAME_NOT_FOUND_MSFT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUnpersistSpatialAnchorMSFT</name></proto> + <param><type>XrSpatialAnchorStoreConnectionMSFT</type> <name>spatialAnchorStore</name></param> + <param>const <type>XrSpatialAnchorPersistenceNameMSFT</type>* <name>spatialAnchorPersistenceName</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrClearSpatialAnchorStoreMSFT</name></proto> + <param><type>XrSpatialAnchorStoreConnectionMSFT</type> <name>spatialAnchorStore</name></param> + </command> + + <!-- XR_BD_body_tracking --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateBodyTrackerBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrBodyTrackerCreateInfoBD</type>* <name>createInfo</name></param> + <param><type>XrBodyTrackerBD</type>* <name>bodyTracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyBodyTrackerBD</name></proto> + <param externsync="true_with_children"><type>XrBodyTrackerBD</type> <name>bodyTracker</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrLocateBodyJointsBD</name></proto> + <param><type>XrBodyTrackerBD</type> <name>bodyTracker</name></param> + <param>const <type>XrBodyJointsLocateInfoBD</type>* <name>locateInfo</name></param> + <param><type>XrBodyJointLocationsBD</type>* <name>locations</name></param> + </command> + + <!-- XR_BD_body_tracking_auxiliary_metrics --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStartBodyTrackingCalibrationAppBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetBodyTrackingStateBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrBodyTrackingStateBD</type>* <name>state</name></param> + </command> + + <!-- XR_HTC_facial_tracking --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateFacialTrackerHTC</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrFacialTrackerCreateInfoHTC</type>* <name>createInfo</name></param> + <param><type>XrFacialTrackerHTC</type>* <name>facialTracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyFacialTrackerHTC</name></proto> + <param externsync="true_with_children"><type>XrFacialTrackerHTC</type> <name>facialTracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetFacialExpressionsHTC</name></proto> + <param><type>XrFacialTrackerHTC</type> <name>facialTracker</name></param> + <param><type>XrFacialExpressionsHTC</type>* <name>facialExpressions</name></param> + </command> + + <!-- XR_HTC_passthrough --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreatePassthroughHTC</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrPassthroughCreateInfoHTC</type>* <name>createInfo</name></param> + <param><type>XrPassthroughHTC</type>* <name>passthrough</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyPassthroughHTC</name></proto> + <param externsync="true_with_children"><type>XrPassthroughHTC</type> <name>passthrough</name></param> + </command> + + <!-- XR_HTC_anchor --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_NAME_INVALID,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorHTC</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialAnchorCreateInfoHTC</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>anchor</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_NOT_AN_ANCHOR_HTC,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialAnchorNameHTC</name></proto> + <param><type>XrSpace</type> <name>anchor</name></param> + <param><type>XrSpatialAnchorNameHTC</type>* <name>name</name></param> + </command> + + <!-- XR_HTCX_vive_tracker_interaction --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateViveTrackerPathsHTCX</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param optional="true"><type>uint32_t</type> <name>pathCapacityInput</name></param> + <param><type>uint32_t</type>* <name>pathCountOutput</name></param> + <param optional="true" len="pathCapacityInput"><type>XrViveTrackerPathsHTCX</type>* <name>paths</name></param> + </command> + + <!-- XR_HTC_body_tracking --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateBodyTrackerHTC</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrBodyTrackerCreateInfoHTC</type>* <name>createInfo</name></param> + <param><type>XrBodyTrackerHTC</type>* <name>bodyTracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyBodyTrackerHTC</name></proto> + <param externsync="true_with_children"><type>XrBodyTrackerHTC</type> <name>bodyTracker</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrLocateBodyJointsHTC</name></proto> + <param><type>XrBodyTrackerHTC</type> <name>bodyTracker</name></param> + <param>const <type>XrBodyJointsLocateInfoHTC</type>* <name>locateInfo</name></param> + <param><type>XrBodyJointLocationsHTC</type>* <name>locations</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetBodySkeletonHTC</name></proto> + <param><type>XrBodyTrackerHTC</type> <name>bodyTracker</name></param> + <param><type>XrSpace</type> <name>baseSpace</name></param> + <param><type>uint32_t</type> <name>skeletonGenerationId</name></param> + <param><type>XrBodySkeletonHTC</type>* <name>skeleton</name></param> + </command> + + <!-- commands for XR_VARJO_marker_tracking --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST"> + <proto><type>XrResult</type> <name>xrSetMarkerTrackingVARJO</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrBool32</type> <name>enabled</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_MARKER_ID_INVALID_VARJO,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST"> + <proto><type>XrResult</type> <name>xrSetMarkerTrackingTimeoutVARJO</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>uint64_t</type> <name>markerId</name></param> + <param><type>XrDuration</type> <name>timeout</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_MARKER_ID_INVALID_VARJO,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST"> + <proto><type>XrResult</type> <name>xrSetMarkerTrackingPredictionVARJO</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>uint64_t</type> <name>markerId</name></param> + <param><type>XrBool32</type> <name>enable</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_MARKER_ID_INVALID_VARJO,XR_ERROR_MARKER_NOT_TRACKED_VARJO,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST"> + <proto><type>XrResult</type> <name>xrGetMarkerSizeVARJO</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>uint64_t</type> <name>markerId</name></param> + <param><type>XrExtent2Df</type>* <name>size</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_MARKER_ID_INVALID_VARJO,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateMarkerSpaceVARJO</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrMarkerSpaceCreateInfoVARJO</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>space</name></param> + </command> + + <!-- XR_META_body_tracking_fidelity --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRequestBodyTrackingFidelityMETA</name></proto> + <param><type>XrBodyTrackerFB</type> <name>bodyTracker</name></param> + <param>const <type>XrBodyTrackingFidelityMETA</type> <name>fidelity</name></param> + </command> + + <!-- commands for XR_ALMALENCE_digital_lens_control --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST"> + <proto><type>XrResult</type> <name>xrSetDigitalLensControlALMALENCE</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrDigitalLensControlALMALENCE</type>* <name>digitalLensControl</name></param> + </command> + + <!-- commands for XR_VARJO_view_offset --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetViewOffsetVARJO</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>float</type> <name>offset</name></param> + </command> + + <!-- commands for XR_OCULUS_external_camera --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateExternalCamerasOCULUS</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true"><type>uint32_t</type> <name>cameraCapacityInput</name></param> + <param><type>uint32_t</type>* <name>cameraCountOutput</name></param> + <param optional="true" len="cameraCapacityInput"><type>XrExternalCameraOCULUS</type>* <name>cameras</name></param> + </command> + + <!-- commands for XR_META_passthrough_color_lut--> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PASSTHROUGH_COLOR_LUT_BUFFER_SIZE_MISMATCH_META,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreatePassthroughColorLutMETA</name></proto> + <param><type>XrPassthroughFB</type> <name>passthrough</name></param> + <param>const <type>XrPassthroughColorLutCreateInfoMETA</type>* <name>createInfo</name></param> + <param><type>XrPassthroughColorLutMETA</type>* <name>colorLut</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyPassthroughColorLutMETA</name></proto> + <param externsync="true_with_children"><type>XrPassthroughColorLutMETA</type> <name>colorLut</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PASSTHROUGH_COLOR_LUT_BUFFER_SIZE_MISMATCH_META,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUpdatePassthroughColorLutMETA</name></proto> + <param><type>XrPassthroughColorLutMETA</type> <name>colorLut</name></param> + <param>const <type>XrPassthroughColorLutUpdateInfoMETA</type>* <name>updateInfo</name></param> + </command> + + <!-- commands for XR_META_performance_metrics --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumeratePerformanceMetricsCounterPathsMETA</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param optional="true"><type>uint32_t</type> <name>counterPathCapacityInput</name></param> + <param><type>uint32_t</type>* <name>counterPathCountOutput</name></param> + <param optional="true" len="counterPathCapacityInput"><type>XrPath</type>* <name>counterPaths</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetPerformanceMetricsStateMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrPerformanceMetricsStateMETA</type>* <name>state</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetPerformanceMetricsStateMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPerformanceMetricsStateMETA</type>* <name>state</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrQueryPerformanceMetricsCounterMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPath</type> <name>counterPath</name></param> + <param><type>XrPerformanceMetricsCounterMETA</type>* <name>counter</name></param> + </command> + + <!-- commands for XR_META_passthrough_preferences --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetPassthroughPreferencesMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPassthroughPreferencesMETA</type>* <name>preferences</name></param> + </command> + + <!-- commands for XR_HTC_foveation --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrApplyFoveationHTC</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrFoveationApplyInfoHTC</type>* <name>applyInfo</name></param> + </command> + + + <!-- commands for XR_ML_compat --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpaceFromCoordinateFrameUIDML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrCoordinateSpaceCreateInfoML</type> *<name>createInfo</name></param> + <param><type>XrSpace</type>* <name>space</name></param> + </command> + + <!-- XR_FB_haptic_pcm --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_ACTION_TYPE_MISMATCH,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetDeviceSampleRateFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrHapticActionInfo</type>* <name>hapticActionInfo</name></param> + <param><type>XrDevicePcmSampleRateGetInfoFB</type>* <name>deviceSampleRate</name></param> + </command> + + <!-- XR_QCOM_tracking_optimization_settings --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_HINT_ALREADY_SET_QCOM,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetTrackingOptimizationSettingsHintQCOM</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrTrackingOptimizationSettingsDomainQCOM</type> <name>domain</name></param> + <param><type>XrTrackingOptimizationSettingsHintQCOM</type> <name>hint</name></param> + </command> + + <!-- commands for XR_FB_spatial_entity_user --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpaceUserFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpaceUserCreateInfoFB</type>* <name>info</name></param> + <param><type>XrSpaceUserFB</type>* <name>user</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceUserIdFB</name></proto> + <param><type>XrSpaceUserFB</type> <name>user</name></param> + <param><type>XrSpaceUserIdFB</type>* <name>userId</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpaceUserFB</name></proto> + <param externsync="true_with_children"><type>XrSpaceUserFB</type> <name>user</name></param> + </command> + + <!-- XR_META_recommended_layer_resolution commands --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LAYER_INVALID,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetRecommendedLayerResolutionMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrRecommendedLayerResolutionGetInfoMETA</type>* <name>info</name></param> + <param><type>XrRecommendedLayerResolutionMETA</type>* <name>resolution</name></param> + </command> + + <!-- commands for XR_META_spatial_entity_persistence --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING,XR_SESSION_NOT_FOCUSED" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INITIALIZATION_FAILED,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_SPACE_RATE_LIMITED_META,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSaveSpacesMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpacesSaveInfoMETA</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING,XR_SESSION_NOT_FOCUSED" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INITIALIZATION_FAILED,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_SPACE_RATE_LIMITED_META,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEraseSpacesMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpacesEraseInfoMETA</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + + <!-- commands for XR_META_spatial_entity_discovery --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INITIALIZATION_FAILED,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPACE_RATE_LIMITED_META,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrDiscoverSpacesMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpaceDiscoveryInfoMETA</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRetrieveSpaceDiscoveryResultsMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrAsyncRequestIdFB</type> <name>requestId</name></param> + <param><type>XrSpaceDiscoveryResultsMETA</type>* <name>results</name></param> + </command> + + <!-- commands for XR_MNDX_force_feedback_curl --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING,XR_SESSION_NOT_FOCUSED" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrApplyForceFeedbackCurlMNDX</name></proto> + <param><type>XrHandTrackerEXT</type> <name>handTracker</name></param> + <param>const <type>XrForceFeedbackCurlApplyLocationsMNDX</type>* <name>locations</name></param> + </command> + + <!-- commands for XR_ANDROID_face_tracking --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateFaceTrackerANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrFaceTrackerCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrFaceTrackerANDROID</type>* <name>faceTracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyFaceTrackerANDROID</name></proto> + <param externsync="true_with_children"><type>XrFaceTrackerANDROID</type> <name>faceTracker</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SERVICE_NOT_READY_ANDROID,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetFaceStateANDROID</name></proto> + <param><type>XrFaceTrackerANDROID</type> <name>faceTracker</name></param> + <param>const <type>XrFaceStateGetInfoANDROID</type>* <name>getInfo</name></param> + <param><type>XrFaceStateANDROID</type>* <name>faceStateOutput</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetFaceCalibrationStateANDROID</name></proto> + <param><type>XrFaceTrackerANDROID</type> <name>faceTracker</name></param> + <param><type>XrBool32</type>* <name>faceIsCalibratedOutput</name></param> + </command> + + <!-- commands for XR_ANDROID_passthrough_camera_state --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetPassthroughCameraStateANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrPassthroughCameraStateGetInfoANDROID</type>* <name>getInfo</name></param> + <param><type>XrPassthroughCameraStateANDROID</type>* <name>cameraStateOutput</name></param> + </command> + + <!-- XR_ANDROID_anchor_sharing_export --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ANCHOR_NOT_OWNED_BY_CALLER_ANDROID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrShareAnchorANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrAnchorSharingInfoANDROID</type>* <name>sharingInfo</name></param> + <param><type>XrAnchorSharingTokenANDROID</type>* <name>anchorToken</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ANCHOR_NOT_OWNED_BY_CALLER_ANDROID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUnshareAnchorANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrSpace</type> <name>anchor</name></param> + </command> + + <!-- XR_ANDROID_trackables_object --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_MISMATCHING_TRACKABLE_TYPE_ANDROID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetTrackableObjectANDROID</name></proto> + <param><type>XrTrackableTrackerANDROID</type> <name>tracker</name></param> + <param>const <type>XrTrackableGetInfoANDROID</type>* <name>getInfo</name></param> + <param><type>XrTrackableObjectANDROID</type>* <name>objectOutput</name></param> + </command> + + <!-- commands for XR_ANDROID_raycast --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateRaycastSupportedTrackableTypesANDROID</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param optional="true"><type>uint32_t</type> <name>trackableTypeCapacityInput</name></param> + <param><type>uint32_t</type>* <name>trackableTypeCountOutput</name></param> + <param optional="true" len="trackableTypeCapacityInput"><type>XrTrackableTypeANDROID</type>* <name>trackableTypes</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_TRACKABLE_TYPE_NOT_SUPPORTED_ANDROID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRaycastANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrRaycastInfoANDROID</type>* <name>rayInfo</name></param> + <param><type>XrRaycastHitResultsANDROID</type>* <name>results</name></param> + </command> + + <!-- XR_ANDROID_trackables_marker --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_MISMATCHING_TRACKABLE_TYPE_ANDROID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetTrackableMarkerANDROID</name></proto> + <param><type>XrTrackableTrackerANDROID</type> <name>tracker</name></param> + <param>const <type>XrTrackableGetInfoANDROID</type>* <name>getInfo</name></param> + <param><type>XrTrackableMarkerANDROID</type>* <name>markerOutput</name></param> + </command> + + <!-- XR_ANDROID_device_anchor_persistence --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSupportedPersistenceAnchorTypesANDROID</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param optional="true"><type>uint32_t</type> <name>trackableTypeCapacityInput</name></param> + <param><type>uint32_t</type>* <name>trackableTypeCountOutput</name></param> + <param optional="true" len="trackableTypeCapacityInput"><type>XrTrackableTypeANDROID</type>* <name>trackableTypes</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateDeviceAnchorPersistenceANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrDeviceAnchorPersistenceCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrDeviceAnchorPersistenceANDROID</type>* <name>outHandle</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyDeviceAnchorPersistenceANDROID</name></proto> + <param externsync="true_with_children"><type>XrDeviceAnchorPersistenceANDROID</type> <name>handle</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ANCHOR_NOT_OWNED_BY_CALLER_ANDROID,XR_ERROR_ANCHOR_NOT_TRACKING_ANDROID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERSISTED_DATA_NOT_READY_ANDROID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPersistAnchorANDROID</name></proto> + <param><type>XrDeviceAnchorPersistenceANDROID</type> <name>handle</name></param> + <param>const <type>XrPersistedAnchorSpaceInfoANDROID</type>* <name>persistedInfo</name></param> + <param><type>XrUuidEXT</type>* <name>anchorIdOutput</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ANCHOR_ID_NOT_FOUND_ANDROID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PERSISTED_DATA_NOT_READY_ANDROID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetAnchorPersistStateANDROID</name></proto> + <param><type>XrDeviceAnchorPersistenceANDROID</type> <name>handle</name></param> + <param>const <type>XrUuidEXT</type>* <name>anchorId</name></param> + <param><type>XrAnchorPersistStateANDROID</type>* <name>persistState</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ANCHOR_ID_NOT_FOUND_ANDROID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERSISTED_DATA_NOT_READY_ANDROID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreatePersistedAnchorSpaceANDROID</name></proto> + <param><type>XrDeviceAnchorPersistenceANDROID</type> <name>handle</name></param> + <param>const <type>XrPersistedAnchorSpaceCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>anchorOutput</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PERSISTED_DATA_NOT_READY_ANDROID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumeratePersistedAnchorsANDROID</name></proto> + <param><type>XrDeviceAnchorPersistenceANDROID</type> <name>handle</name></param> + <param optional="true"><type>uint32_t</type> <name>anchorIdCapacityInput</name></param> + <param><type>uint32_t</type>* <name>anchorIdCountOutput</name></param> + <param optional="true" len="anchorIdCapacityInput"><type>XrUuidEXT</type>* <name>anchorIds</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ANCHOR_ID_NOT_FOUND_ANDROID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERSISTED_DATA_NOT_READY_ANDROID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUnpersistAnchorANDROID</name></proto> + <param><type>XrDeviceAnchorPersistenceANDROID</type> <name>handle</name></param> + <param>const <type>XrUuidEXT</type>* <name>anchorId</name></param> + </command> + + <!-- commands for XR_ANDROID_performance_metrics --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumeratePerformanceMetricsCounterPathsANDROID</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param optional="true"><type>uint32_t</type> <name>counterPathCapacityInput</name></param> + <param><type>uint32_t</type>* <name>counterPathCountOutput</name></param> + <param optional="true" len="counterPathCapacityInput"><type>XrPath</type>* <name>counterPaths</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetPerformanceMetricsStateANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrPerformanceMetricsStateANDROID</type>* <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetPerformanceMetricsStateANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPerformanceMetricsStateANDROID</type>* <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrQueryPerformanceMetricsCounterANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPath</type> <name>counterPath</name></param> + <param><type>XrPerformanceMetricsCounterANDROID</type>* <name>counter</name></param> + </command> + + <!-- XR_ANDROID_trackables_qr_code --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_MISMATCHING_TRACKABLE_TYPE_ANDROID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetTrackableQrCodeANDROID</name></proto> + <param><type>XrTrackableTrackerANDROID</type> <name>tracker</name></param> + <param>const <type>XrTrackableGetInfoANDROID</type>* <name>getInfo</name></param> + <param><type>XrTrackableQrCodeANDROID</type>* <name>qrCodeOutput</name></param> + </command> + + <!-- commands for XR_ANDROID_composition_layer_passthrough_mesh --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_MESH_DATA_LIMIT_EXCEEDED_ANDROID,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreatePassthroughLayerANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrPassthroughLayerCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrPassthroughLayerANDROID</type>* <name>layer</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyPassthroughLayerANDROID</name></proto> + <param externsync="true_with_children"><type>XrPassthroughLayerANDROID</type> <name>layer</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_MESH_DATA_LIMIT_EXCEEDED_ANDROID,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetPassthroughLayerMeshANDROID</name></proto> + <param><type>XrPassthroughLayerANDROID</type> <name>layer</name></param> + <param>const <type>XrPassthroughLayerMeshANDROID</type>* <name>mesh</name></param> + </command> + + <!-- XR_ANDROID_scene_meshing --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSupportedSemanticLabelSetsANDROID</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param optional="true"><type>uint32_t</type> <name>supportedSemanticLabelSetsInputCapacity</name></param> + <param><type>uint32_t</type>* <name>supportedSemanticLabelSetsOutputCount</name></param> + <param optional="true" len="supportedSemanticLabelSetsInputCapacity"><type>XrSceneMeshSemanticLabelSetANDROID</type>* <name>supportedSemanticLabelSets</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSceneMeshingTrackerANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSceneMeshingTrackerCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrSceneMeshingTrackerANDROID</type>* <name>tracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySceneMeshingTrackerANDROID</name></proto> + <param externsync="true_with_children"><type>XrSceneMeshingTrackerANDROID</type> <name>tracker</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID"> + <proto><type>XrResult</type> <name>xrCreateSceneMeshSnapshotANDROID</name></proto> + <param><type>XrSceneMeshingTrackerANDROID</type> <name>tracker</name></param> + <param>const <type>XrSceneMeshSnapshotCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrSceneMeshSnapshotCreationResultANDROID</type>* <name>outSnapshotCreationResult</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySceneMeshSnapshotANDROID</name></proto> + <param externsync="true_with_children"><type>XrSceneMeshSnapshotANDROID</type> <name>snapshot</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetAllSubmeshStatesANDROID</name></proto> + <param><type>XrSceneMeshSnapshotANDROID</type> <name>snapshot</name></param> + <param optional="true"><type>uint32_t</type> <name>submeshStateCapacityInput</name></param> + <param><type>uint32_t</type>* <name>submeshStateCountOutput</name></param> + <param optional="true" len="submeshStateCapacityInput"><type>XrSceneSubmeshStateANDROID</type>* <name>submeshStates</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSubmeshDataANDROID</name></proto> + <param><type>XrSceneMeshSnapshotANDROID</type> <name>snapshot</name></param> + <param><type>uint32_t</type> <name>submeshDataCount</name></param> + <param len="submeshDataCount"><type>XrSceneSubmeshDataANDROID</type>* <name>inoutSubmeshData</name></param> + </command> + + <!-- commands for XR_ANDROID_eye_tracking --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateEyeTrackerANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrEyeTrackerCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrEyeTrackerANDROID</type>* <name>eyeTracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyEyeTrackerANDROID</name></proto> + <param externsync="true_with_children"><type>XrEyeTrackerANDROID</type> <name>eyeTracker</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetCoarseTrackingEyesInfoANDROID</name></proto> + <param><type>XrEyeTrackerANDROID</type> <name>eyeTracker</name></param> + <param>const <type>XrEyesGetInfoANDROID</type>* <name>getInfo</name></param> + <param><type>XrEyesANDROID</type>* <name>eyesOutput</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetFineTrackingEyesInfoANDROID</name></proto> + <param><type>XrEyeTrackerANDROID</type> <name>eyeTracker</name></param> + <param>const <type>XrEyesGetInfoANDROID</type>* <name>getInfo</name></param> + <param><type>XrEyesANDROID</type>* <name>eyesOutput</name></param> + </command> + + <!-- commands for XR_ANDROID_light_estimation --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST"> + <proto><type>XrResult</type> <name>xrCreateLightEstimatorANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrLightEstimatorCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrLightEstimatorANDROID</type>* <name>outHandle</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyLightEstimatorANDROID</name></proto> + <param externsync="true_with_children"><type>XrLightEstimatorANDROID</type> <name>estimator</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetLightEstimateANDROID</name></proto> + <param><type>XrLightEstimatorANDROID</type> <name>estimator</name></param> + <param>const <type>XrLightEstimateGetInfoANDROID</type>* <name>input</name></param> + <param><type>XrLightEstimateANDROID</type>* <name>output</name></param> + </command> + + <!-- XR_EXT_plane_detection --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PLANE_DETECTION_PERMISSION_DENIED_EXT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreatePlaneDetectorEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrPlaneDetectorCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrPlaneDetectorEXT</type>* <name>planeDetector</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyPlaneDetectorEXT</name></proto> + <param externsync="true_with_children"><type>XrPlaneDetectorEXT</type> <name>planeDetector</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPACE_NOT_LOCATABLE_EXT,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrBeginPlaneDetectionEXT</name></proto> + <param><type>XrPlaneDetectorEXT</type> <name>planeDetector</name></param> + <param>const <type>XrPlaneDetectorBeginInfoEXT</type>* <name>beginInfo</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetPlaneDetectionStateEXT</name></proto> + <param><type>XrPlaneDetectorEXT</type> <name>planeDetector</name></param> + <param><type>XrPlaneDetectionStateEXT</type>* <name>state</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPACE_NOT_LOCATABLE_EXT,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetPlaneDetectionsEXT</name></proto> + <param><type>XrPlaneDetectorEXT</type> <name>planeDetector</name></param> + <param>const <type>XrPlaneDetectorGetInfoEXT</type>* <name>info</name></param> + <param><type>XrPlaneDetectorLocationsEXT</type>* <name>locations</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetPlanePolygonBufferEXT</name></proto> + <param><type>XrPlaneDetectorEXT</type> <name>planeDetector</name></param> + <param><type>uint64_t</type> <name>planeId</name></param> + <param><type>uint32_t</type> <name>polygonBufferIndex</name></param> + <param><type>XrPlaneDetectorPolygonBufferEXT</type>* <name>polygonBuffer</name></param> + </command> + + <!-- commands for XR_META_virtual_keyboard --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateVirtualKeyboardMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrVirtualKeyboardCreateInfoMETA</type>* <name>createInfo</name></param> + <param><type>XrVirtualKeyboardMETA</type>* <name>keyboard</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyVirtualKeyboardMETA</name></proto> + <param externsync="true_with_children"><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateVirtualKeyboardSpaceMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></param> + <param>const <type>XrVirtualKeyboardSpaceCreateInfoMETA</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>keyboardSpace</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSuggestVirtualKeyboardLocationMETA</name></proto> + <param><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></param> + <param>const <type>XrVirtualKeyboardLocationInfoMETA</type>* <name>locationInfo</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetVirtualKeyboardScaleMETA</name></proto> + <param><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></param> + <param><type>float</type>* <name>scale</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetVirtualKeyboardModelVisibilityMETA</name></proto> + <param><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></param> + <param>const <type>XrVirtualKeyboardModelVisibilitySetInfoMETA</type>* <name>modelVisibility</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetVirtualKeyboardModelAnimationStatesMETA</name></proto> + <param><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></param> + <param><type>XrVirtualKeyboardModelAnimationStatesMETA</type>* <name>animationStates</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetVirtualKeyboardDirtyTexturesMETA</name></proto> + <param><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></param> + <param optional="true"><type>uint32_t</type> <name>textureIdCapacityInput</name></param> + <param><type>uint32_t</type>* <name>textureIdCountOutput</name></param> + <param optional="true" len="textureIdCapacityInput"><type>uint64_t</type>* <name>textureIds</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetVirtualKeyboardTextureDataMETA</name></proto> + <param><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></param> + <param><type>uint64_t</type> <name>textureId</name></param> + <param><type>XrVirtualKeyboardTextureDataMETA</type>* <name>textureData</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSendVirtualKeyboardInputMETA</name></proto> + <param><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></param> + <param>const <type>XrVirtualKeyboardInputInfoMETA</type>* <name>info</name></param> + <param><type>XrPosef</type>* <name>interactorRootPose</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrChangeVirtualKeyboardTextContextMETA</name></proto> + <param><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></param> + <param>const <type>XrVirtualKeyboardTextContextChangeInfoMETA</type>* <name>changeInfo</name></param> + </command> + + <!-- XR_ML_user_calibration --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnableUserCalibrationEventsML</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrUserCalibrationEnableEventsInfoML</type>* <name>enableInfo</name></param> + </command> + + <!-- XR_ML_localization_map --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LOCALIZATION_MAP_PERMISSION_DENIED_ML,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnableLocalizationEventsML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrLocalizationEnableEventsInfoML</type> * <name>info</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LOCALIZATION_MAP_PERMISSION_DENIED_ML,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrQueryLocalizationMapsML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true">const <type>XrLocalizationMapQueryInfoBaseHeaderML</type>* <name>queryInfo</name></param> + <param optional="true"><type>uint32_t</type> <name>mapCapacityInput</name></param> + <param><type>uint32_t</type> * <name>mapCountOutput</name></param> + <param optional="true" len="mapCapacityInput"><type>XrLocalizationMapML</type>* <name>maps</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LOCALIZATION_MAP_FAIL_ML,XR_ERROR_LOCALIZATION_MAP_PERMISSION_DENIED_ML,XR_ERROR_LOCALIZATION_MAP_UNAVAILABLE_ML,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRequestMapLocalizationML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrMapLocalizationRequestInfoML</type>* <name>requestInfo</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LOCALIZATION_MAP_ALREADY_EXISTS_ML,XR_ERROR_LOCALIZATION_MAP_IMPORT_EXPORT_PERMISSION_DENIED_ML,XR_ERROR_LOCALIZATION_MAP_INCOMPATIBLE_ML,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrImportLocalizationMapML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrLocalizationMapImportInfoML</type>* <name>importInfo</name></param> + <param optional="true"><type>XrUuidEXT</type>* <name>mapUuid</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_LOCALIZATION_MAP_CANNOT_EXPORT_CLOUD_MAP_ML,XR_ERROR_LOCALIZATION_MAP_IMPORT_EXPORT_PERMISSION_DENIED_ML,XR_ERROR_LOCALIZATION_MAP_UNAVAILABLE_ML,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateExportedLocalizationMapML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrUuidEXT</type>* <name>mapUuid</name></param> + <param><type>XrExportedLocalizationMapML</type>* <name>map</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyExportedLocalizationMapML</name></proto> + <param externsync="true_with_children"><type>XrExportedLocalizationMapML</type> <name>map</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetExportedLocalizationMapDataML</name></proto> + <param><type>XrExportedLocalizationMapML</type> <name>map</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>char</type>* <name>buffer</name></param> + </command> + + <!-- commands for XR_ML_marker_understanding --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_MARKER_DETECTOR_INVALID_CREATE_INFO_ML,XR_ERROR_MARKER_DETECTOR_PERMISSION_DENIED_ML,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateMarkerDetectorML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrMarkerDetectorCreateInfoML</type>* <name>createInfo</name></param> + <param><type>XrMarkerDetectorML</type>* <name>markerDetector</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyMarkerDetectorML</name></proto> + <param externsync="true_with_children"><type>XrMarkerDetectorML</type> <name>markerDetector</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSnapshotMarkerDetectorML</name></proto> + <param><type>XrMarkerDetectorML</type> <name>markerDetector</name></param> + <param><type>XrMarkerDetectorSnapshotInfoML</type>* <name>snapshotInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetMarkerDetectorStateML</name></proto> + <param><type>XrMarkerDetectorML</type> <name>markerDetector</name></param> + <param><type>XrMarkerDetectorStateML</type>* <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetMarkersML</name></proto> + <param><type>XrMarkerDetectorML</type> <name>markerDetector</name></param> + <param optional="true"><type>uint32_t</type> <name>markerCapacityInput</name></param> + <param><type>uint32_t</type>* <name>markerCountOutput</name></param> + <param optional="true" len="markerCapacityInput"><type>XrMarkerML</type>* <name>markers</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_MARKER_INVALID_ML,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetMarkerReprojectionErrorML</name></proto> + <param><type>XrMarkerDetectorML</type> <name>markerDetector</name></param> + <param><type>XrMarkerML</type> <name>marker</name></param> + <param><type>float</type>* <name>reprojectionErrorMeters</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_MARKER_INVALID_ML,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetMarkerLengthML</name></proto> + <param><type>XrMarkerDetectorML</type> <name>markerDetector</name></param> + <param><type>XrMarkerML</type> <name>marker</name></param> + <param><type>float</type>* <name>meters</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_MARKER_DETECTOR_INVALID_DATA_QUERY_ML,XR_ERROR_MARKER_INVALID_ML,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetMarkerNumberML</name></proto> + <param><type>XrMarkerDetectorML</type> <name>markerDetector</name></param> + <param><type>XrMarkerML</type> <name>marker</name></param> + <param><type>uint64_t</type>* <name>number</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_MARKER_DETECTOR_INVALID_DATA_QUERY_ML,XR_ERROR_MARKER_INVALID_ML,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetMarkerStringML</name></proto> + <param><type>XrMarkerDetectorML</type> <name>markerDetector</name></param> + <param><type>XrMarkerML</type> <name>marker</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>char</type>* <name>buffer</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_MARKER_DETECTOR_LOCATE_FAILED_ML,XR_ERROR_MARKER_INVALID_ML,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateMarkerSpaceML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrMarkerSpaceCreateInfoML</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>space</name></param> + </command> + + <!-- XR_EXT_future --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPollFutureEXT</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrFuturePollInfoEXT</type>* <name>pollInfo</name></param> + <param><type>XrFuturePollResultEXT</type>* <name>pollResult</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCancelFutureEXT</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param externsync="cancelInfo.future">const <type>XrFutureCancelInfoEXT</type>* <name>cancelInfo</name></param> + </command> + + + <!-- XR_META_environment_depth --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_NOT_PERMITTED_PASSTHROUGH_FB,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateEnvironmentDepthProviderMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrEnvironmentDepthProviderCreateInfoMETA</type>* <name>createInfo</name></param> + <param><type>XrEnvironmentDepthProviderMETA</type>* <name>environmentDepthProvider</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyEnvironmentDepthProviderMETA</name></proto> + <param externsync="true_with_children"><type>XrEnvironmentDepthProviderMETA</type> <name>environmentDepthProvider</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_UNEXPECTED_STATE_PASSTHROUGH_FB"> + <proto><type>XrResult</type> <name>xrStartEnvironmentDepthProviderMETA</name></proto> + <param><type>XrEnvironmentDepthProviderMETA</type> <name>environmentDepthProvider</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_UNEXPECTED_STATE_PASSTHROUGH_FB"> + <proto><type>XrResult</type> <name>xrStopEnvironmentDepthProviderMETA</name></proto> + <param><type>XrEnvironmentDepthProviderMETA</type> <name>environmentDepthProvider</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateEnvironmentDepthSwapchainMETA</name></proto> + <param><type>XrEnvironmentDepthProviderMETA</type> <name>environmentDepthProvider</name></param> + <param>const <type>XrEnvironmentDepthSwapchainCreateInfoMETA</type>* <name>createInfo</name></param> + <param><type>XrEnvironmentDepthSwapchainMETA</type>* <name>swapchain</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyEnvironmentDepthSwapchainMETA</name></proto> + <param externsync="true_with_children"><type>XrEnvironmentDepthSwapchainMETA</type> <name>swapchain</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateEnvironmentDepthSwapchainImagesMETA</name></proto> + <param><type>XrEnvironmentDepthSwapchainMETA</type> <name>swapchain</name></param> + <param optional="true"><type>uint32_t</type> <name>imageCapacityInput</name></param> + <param><type>uint32_t</type>* <name>imageCountOutput</name></param> + <param optional="true" len="imageCapacityInput"><type>XrSwapchainImageBaseHeader</type>* <name>images</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetEnvironmentDepthSwapchainStateMETA</name></proto> + <param><type>XrEnvironmentDepthSwapchainMETA</type> <name>swapchain</name></param> + <param><type>XrEnvironmentDepthSwapchainStateMETA</type>* <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_ENVIRONMENT_DEPTH_NOT_AVAILABLE_META,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrAcquireEnvironmentDepthImageMETA</name></proto> + <param><type>XrEnvironmentDepthProviderMETA</type> <name>environmentDepthProvider</name></param> + <param>const <type>XrEnvironmentDepthImageAcquireInfoMETA</type>* <name>acquireInfo</name></param> + <param><type>XrEnvironmentDepthImageMETA</type>* <name>environmentDepthImage</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetEnvironmentDepthHandRemovalMETA</name></proto> + <param><type>XrEnvironmentDepthProviderMETA</type> <name>environmentDepthProvider</name></param> + <param>const <type>XrEnvironmentDepthHandRemovalSetInfoMETA</type>* <name>setInfo</name></param> + </command> + + <!-- XR_EXT_stationary_reference_space --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetStationaryReferenceSpaceGenerationIdEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true">const <type>XrStationaryReferenceSpaceGenerationIdGetInfoEXT</type>* <name>getInfo</name></param> + <param><type>XrStationaryReferenceSpaceGenerationIdResultEXT</type>* <name>generationIdResult</name></param> + </command> + + <!-- XR_ML_facial_expression --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FACIAL_EXPRESSION_PERMISSION_DENIED_ML,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateFacialExpressionClientML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrFacialExpressionClientCreateInfoML</type>* <name>createInfo</name></param> + <param><type>XrFacialExpressionClientML</type>* <name>facialExpressionClient</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyFacialExpressionClientML</name></proto> + <param externsync="true_with_children"><type>XrFacialExpressionClientML</type> <name>facialExpressionClient</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetFacialExpressionBlendShapePropertiesML</name></proto> + <param><type>XrFacialExpressionClientML</type> <name>facialExpressionClient</name></param> + <param>const <type>XrFacialExpressionBlendShapeGetInfoML</type>* <name>blendShapeGetInfo</name></param> + <param><type>uint32_t</type> <name>blendShapeCount</name></param> + <param len="blendShapeCount"><type>XrFacialExpressionBlendShapePropertiesML</type>* <name>blendShapes</name></param> + </command> + + <!-- XR_KHR_locate_spaces --> + <command name="xrLocateSpacesKHR" alias="xrLocateSpaces"/> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrLocateSpaces</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpacesLocateInfo</type>* <name>locateInfo</name></param> + <param><type>XrSpaceLocations</type>* <name>spaceLocations</name></param> + </command> + + <!-- XR_EXT_spatial_entity --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSpatialCapabilitiesEXT</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param optional="true"><type>uint32_t</type> <name>capabilityCapacityInput</name></param> + <param><type>uint32_t</type>* <name>capabilityCountOutput</name></param> + <param optional="true" len="capabilityCapacityInput"><type>XrSpatialCapabilityEXT</type>* <name>capabilities</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSpatialCapabilityComponentTypesEXT</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrSpatialCapabilityEXT</type> <name>capability</name></param> + <param><type>XrSpatialCapabilityComponentTypesEXT</type>* <name>capabilityComponents</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSpatialCapabilityFeaturesEXT</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrSpatialCapabilityEXT</type> <name>capability</name></param> + <param optional="true"><type>uint32_t</type> <name>capabilityFeatureCapacityInput</name></param> + <param><type>uint32_t</type>* <name>capabilityFeatureCountOutput</name></param> + <param optional="true" len="capabilityFeatureCapacityInput"><type>XrSpatialCapabilityFeatureEXT</type>* <name>capabilityFeatures</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT,XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT,XR_ERROR_SPATIAL_COMPONENT_UNSUPPORTED_FOR_CAPABILITY_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialContextAsyncEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialContextCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialContextCompleteEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrCreateSpatialContextCompletionEXT</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpatialContextEXT</name></proto> + <param externsync="true_with_children"><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_COMPONENT_NOT_ENABLED_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialDiscoverySnapshotAsyncEXT</name></proto> + <param><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + <param>const <type>XrSpatialDiscoverySnapshotCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialDiscoverySnapshotCompleteEXT</name></proto> + <param><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + <param>const <type>XrCreateSpatialDiscoverySnapshotCompletionInfoEXT</type>* <name>createSnapshotCompletionInfo</name></param> + <param><type>XrCreateSpatialDiscoverySnapshotCompletionEXT</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrQuerySpatialComponentDataEXT</name></proto> + <param><type>XrSpatialSnapshotEXT</type> <name>snapshot</name></param> + <param>const <type>XrSpatialComponentDataQueryConditionEXT</type>* <name>queryCondition</name></param> + <param><type>XrSpatialComponentDataQueryResultEXT</type>* <name>queryResult</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpatialSnapshotEXT</name></proto> + <param externsync="true_with_children"><type>XrSpatialSnapshotEXT</type> <name>snapshot</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_ENTITY_ID_INVALID_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialEntityFromIdEXT</name></proto> + <param><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + <param>const <type>XrSpatialEntityFromIdCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrSpatialEntityEXT</type>* <name>spatialEntity</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpatialEntityEXT</name></proto> + <param externsync="true_with_children"><type>XrSpatialEntityEXT</type> <name>spatialEntity</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_COMPONENT_NOT_ENABLED_EXT,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialUpdateSnapshotEXT</name></proto> + <param><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + <param>const <type>XrSpatialUpdateSnapshotCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrSpatialSnapshotEXT</type>* <name>snapshot</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialBufferStringEXT</name></proto> + <param><type>XrSpatialSnapshotEXT</type> <name>snapshot</name></param> + <param>const <type>XrSpatialBufferGetInfoEXT</type>* <name>info</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>char</type>* <name>buffer</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialBufferUint8EXT</name></proto> + <param><type>XrSpatialSnapshotEXT</type> <name>snapshot</name></param> + <param>const <type>XrSpatialBufferGetInfoEXT</type>* <name>info</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>uint8_t</type>* <name>buffer</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialBufferUint16EXT</name></proto> + <param><type>XrSpatialSnapshotEXT</type> <name>snapshot</name></param> + <param>const <type>XrSpatialBufferGetInfoEXT</type>* <name>info</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>uint16_t</type>* <name>buffer</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialBufferUint32EXT</name></proto> + <param><type>XrSpatialSnapshotEXT</type> <name>snapshot</name></param> + <param>const <type>XrSpatialBufferGetInfoEXT</type>* <name>info</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>uint32_t</type>* <name>buffer</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialBufferFloatEXT</name></proto> + <param><type>XrSpatialSnapshotEXT</type> <name>snapshot</name></param> + <param>const <type>XrSpatialBufferGetInfoEXT</type>* <name>info</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>float</type>* <name>buffer</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialBufferVector2fEXT</name></proto> + <param><type>XrSpatialSnapshotEXT</type> <name>snapshot</name></param> + <param>const <type>XrSpatialBufferGetInfoEXT</type>* <name>info</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>XrVector2f</type>* <name>buffer</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialBufferVector3fEXT</name></proto> + <param><type>XrSpatialSnapshotEXT</type> <name>snapshot</name></param> + <param>const <type>XrSpatialBufferGetInfoEXT</type>* <name>info</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>XrVector3f</type>* <name>buffer</name></param> + </command> + + <!-- XR_EXT_spatial_anchor --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorEXT</name></proto> + <param><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + <param>const <type>XrSpatialAnchorCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrSpatialEntityIdEXT</type>* <name>anchorEntityId</name></param> + <param><type>XrSpatialEntityEXT</type>* <name>anchorEntity</name></param> + </command> + + <!-- XR_EXT_spatial_persistence --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSpatialPersistenceScopesEXT</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param optional="true"><type>uint32_t</type> <name>persistenceScopeCapacityInput</name></param> + <param><type>uint32_t</type>* <name>persistenceScopeCountOutput</name></param> + <param optional="true" len="persistenceScopeCapacityInput"><type>XrSpatialPersistenceScopeEXT</type>* <name>persistenceScopes</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_PERSISTENCE_SCOPE_UNSUPPORTED_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialPersistenceContextAsyncEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialPersistenceContextCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialPersistenceContextCompleteEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrCreateSpatialPersistenceContextCompletionEXT</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpatialPersistenceContextEXT</name></proto> + <param externsync="true_with_children"><type>XrSpatialPersistenceContextEXT</type> <name>persistenceContext</name></param> + </command> + + <!-- XR_EXT_spatial_persistence_operations --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_ENTITY_ID_INVALID_EXT,XR_ERROR_SPATIAL_PERSISTENCE_SCOPE_INCOMPATIBLE_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPersistSpatialEntityAsyncEXT</name></proto> + <param><type>XrSpatialPersistenceContextEXT</type> <name>persistenceContext</name></param> + <param>const <type>XrSpatialEntityPersistInfoEXT</type>* <name>persistInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPersistSpatialEntityCompleteEXT</name></proto> + <param><type>XrSpatialPersistenceContextEXT</type> <name>persistenceContext</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrPersistSpatialEntityCompletionEXT</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUnpersistSpatialEntityAsyncEXT</name></proto> + <param><type>XrSpatialPersistenceContextEXT</type> <name>persistenceContext</name></param> + <param>const <type>XrSpatialEntityUnpersistInfoEXT</type>* <name>unpersistInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUnpersistSpatialEntityCompleteEXT</name></proto> + <param><type>XrSpatialPersistenceContextEXT</type> <name>persistenceContext</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrUnpersistSpatialEntityCompletionEXT</type>* <name>completion</name></param> + </command> + + <!-- XR_ML_system_notifications --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_NOTIFICATION_INCOMPATIBLE_SKU_ML,XR_ERROR_SYSTEM_NOTIFICATION_PERMISSION_DENIED_ML,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetSystemNotificationsML</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrSystemNotificationsSetInfoML</type>* <name>info</name></param> + </command> + + <!-- XR_ML_spatial_anchors --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_ANCHORS_PERMISSION_DENIED_ML,XR_ERROR_SPATIAL_ANCHORS_SPACE_NOT_LOCATABLE_ML,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorsAsyncML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialAnchorsCreateInfoBaseHeaderML</type>* <name>createInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorsCompleteML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrCreateSpatialAnchorsCompletionML</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialAnchorStateML</name></proto> + <param><type>XrSpace</type> <name>anchor</name></param> + <param><type>XrSpatialAnchorStateML</type>* <name>state</name></param> + </command> + + <!-- XR_ML_spatial_anchors_storage --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_ANCHORS_PERMISSION_DENIED_ML,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorsStorageML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialAnchorsCreateStorageInfoML</type>* <name>createInfo</name></param> + <param><type>XrSpatialAnchorsStorageML</type>* <name>storage</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpatialAnchorsStorageML</name></proto> + <param externsync="true_with_children"><type>XrSpatialAnchorsStorageML</type> <name>storage</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_ANCHORS_SPACE_NOT_LOCATABLE_ML,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrQuerySpatialAnchorsAsyncML</name></proto> + <param><type>XrSpatialAnchorsStorageML</type> <name>storage</name></param> + <param>const <type>XrSpatialAnchorsQueryInfoBaseHeaderML</type>* <name>queryInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrQuerySpatialAnchorsCompleteML</name></proto> + <param><type>XrSpatialAnchorsStorageML</type> <name>storage</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrSpatialAnchorsQueryCompletionML</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPublishSpatialAnchorsAsyncML</name></proto> + <param><type>XrSpatialAnchorsStorageML</type> <name>storage</name></param> + <param>const <type>XrSpatialAnchorsPublishInfoML</type>* <name>publishInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPublishSpatialAnchorsCompleteML</name></proto> + <param><type>XrSpatialAnchorsStorageML</type> <name>storage</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrSpatialAnchorsPublishCompletionML</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrDeleteSpatialAnchorsAsyncML</name></proto> + <param><type>XrSpatialAnchorsStorageML</type> <name>storage</name></param> + <param>const <type>XrSpatialAnchorsDeleteInfoML</type>* <name>deleteInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrDeleteSpatialAnchorsCompleteML</name></proto> + <param><type>XrSpatialAnchorsStorageML</type> <name>storage</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrSpatialAnchorsDeleteCompletionML</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUpdateSpatialAnchorsExpirationAsyncML</name></proto> + <param><type>XrSpatialAnchorsStorageML</type> <name>storage</name></param> + <param>const <type>XrSpatialAnchorsUpdateExpirationInfoML</type>* <name>updateInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUpdateSpatialAnchorsExpirationCompleteML</name></proto> + <param><type>XrSpatialAnchorsStorageML</type> <name>storage</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrSpatialAnchorsUpdateExpirationCompletionML</type>* <name>completion</name></param> + </command> + + <!-- XR_ML_world_mesh_detection --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_WORLD_MESH_DETECTOR_PERMISSION_DENIED_ML"> + <proto><type>XrResult</type> <name>xrCreateWorldMeshDetectorML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrWorldMeshDetectorCreateInfoML</type>* <name>createInfo</name></param> + <param><type>XrWorldMeshDetectorML</type>* <name>detector</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyWorldMeshDetectorML</name></proto> + <param externsync="true_with_children"><type>XrWorldMeshDetectorML</type> <name>detector</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_WORLD_MESH_DETECTOR_SPACE_NOT_LOCATABLE_ML"> + <proto><type>XrResult</type> <name>xrRequestWorldMeshStateAsyncML</name></proto> + <param><type>XrWorldMeshDetectorML</type> <name>detector</name></param> + <param>const <type>XrWorldMeshStateRequestInfoML</type>* <name>stateRequest</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRequestWorldMeshStateCompleteML</name></proto> + <param><type>XrWorldMeshDetectorML</type> <name>detector</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrWorldMeshStateRequestCompletionML</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetWorldMeshBufferRecommendSizeML</name></proto> + <param><type>XrWorldMeshDetectorML</type> <name>detector</name></param> + <param>const <type>XrWorldMeshBufferRecommendedSizeInfoML</type>* <name>sizeInfo</name></param> + <param><type>XrWorldMeshBufferSizeML</type>* <name>size</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrAllocateWorldMeshBufferML</name></proto> + <param><type>XrWorldMeshDetectorML</type> <name>detector</name></param> + <param>const <type>XrWorldMeshBufferSizeML</type>* <name>size</name></param> + <param><type>XrWorldMeshBufferML</type>* <name>buffer</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrFreeWorldMeshBufferML</name></proto> + <param><type>XrWorldMeshDetectorML</type> <name>detector</name></param> + <param>const <type>XrWorldMeshBufferML</type>* <name>buffer</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRequestWorldMeshAsyncML</name></proto> + <param><type>XrWorldMeshDetectorML</type> <name>detector</name></param> + <param>const <type>XrWorldMeshGetInfoML</type>* <name>getInfo</name></param> + <param><type>XrWorldMeshBufferML</type>* <name>buffer</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_WORLD_MESH_DETECTOR_SPACE_NOT_LOCATABLE_ML"> + <proto><type>XrResult</type> <name>xrRequestWorldMeshCompleteML</name></proto> + <param><type>XrWorldMeshDetectorML</type> <name>detector</name></param> + <param>const <type>XrWorldMeshRequestCompletionInfoML</type>* <name>completionInfo</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrWorldMeshRequestCompletionML</type>* <name>completion</name></param> + </command> + + <!-- XR_EXT_render_model --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RENDER_MODEL_ID_INVALID_EXT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateRenderModelEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrRenderModelCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrRenderModelEXT</type>* <name>renderModel</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyRenderModelEXT</name></proto> + <param externsync="true_with_children"><type>XrRenderModelEXT</type> <name>renderModel</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetRenderModelPropertiesEXT</name></proto> + <param><type>XrRenderModelEXT</type> <name>renderModel</name></param> + <param optional="true">const <type>XrRenderModelPropertiesGetInfoEXT</type>* <name>getInfo</name></param> + <param><type>XrRenderModelPropertiesEXT</type>* <name>properties</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateRenderModelSpaceEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrRenderModelSpaceCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>space</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RENDER_MODEL_ASSET_UNAVAILABLE_EXT,XR_ERROR_RENDER_MODEL_GLTF_EXTENSION_REQUIRED_EXT,XR_ERROR_RENDER_MODEL_ID_INVALID_EXT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateRenderModelAssetEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrRenderModelAssetCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrRenderModelAssetEXT</type>* <name>asset</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyRenderModelAssetEXT</name></proto> + <param externsync="true_with_children"><type>XrRenderModelAssetEXT</type> <name>asset</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetRenderModelAssetDataEXT</name></proto> + <param><type>XrRenderModelAssetEXT</type> <name>asset</name></param> + <param optional="true">const <type>XrRenderModelAssetDataGetInfoEXT</type>* <name>getInfo</name></param> + <param><type>XrRenderModelAssetDataEXT</type>* <name>buffer</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetRenderModelAssetPropertiesEXT</name></proto> + <param><type>XrRenderModelAssetEXT</type> <name>asset</name></param> + <param optional="true">const <type>XrRenderModelAssetPropertiesGetInfoEXT</type>* <name>getInfo</name></param> + <param><type>XrRenderModelAssetPropertiesEXT</type>* <name>properties</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetRenderModelStateEXT</name></proto> + <param><type>XrRenderModelEXT</type> <name>renderModel</name></param> + <param>const <type>XrRenderModelStateGetInfoEXT</type>* <name>getInfo</name></param> + <param><type>XrRenderModelStateEXT</type>* <name>state</name></param> + </command> + + <!-- XR_EXT_interaction_render_model --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateInteractionRenderModelIdsEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrInteractionRenderModelIdsEnumerateInfoEXT</type>* <name>getInfo</name></param> + <param optional="true"><type>uint32_t</type> <name>renderModelIdCapacityInput</name></param> + <param><type>uint32_t</type>* <name>renderModelIdCountOutput</name></param> + <param len="renderModelIdCapacityInput" optional="true"><type>XrRenderModelIdEXT</type>* <name>renderModelIds</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_NOT_INTERACTION_RENDER_MODEL_EXT,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateRenderModelSubactionPathsEXT</name></proto> + <param><type>XrRenderModelEXT</type> <name>renderModel</name></param> + <param optional="true">const <type>XrInteractionRenderModelSubactionPathInfoEXT</type>* <name>info</name></param> + <param optional="true"><type>uint32_t</type> <name>pathCapacityInput</name></param> + <param><type>uint32_t</type>* <name>pathCountOutput</name></param> + <param len="pathCapacityInput" optional="true"><type>XrPath</type>* <name>paths</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_NOT_INTERACTION_RENDER_MODEL_EXT,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RENDER_MODEL_ID_INVALID_EXT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetRenderModelPoseTopLevelUserPathEXT</name></proto> + <param><type>XrRenderModelEXT</type> <name>renderModel</name></param> + <param>const <type>XrInteractionRenderModelTopLevelUserPathGetInfoEXT</type>* <name>info</name></param> + <param><type>XrPath</type>* <name>topLevelUserPath</name></param> + </command> + + <!-- XR_BD_spatial_audio_rendering --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSupportedAudioSampleRateBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true"><type>uint32_t</type> <name>sampleRateCapacityInput</name></param> + <param><type>uint32_t</type>* <name>sampleRateCountOutput</name></param> + <param len="sampleRateCapacityInput" optional="true"><type>XrAudioSampleRateBD</type>* <name>sampleRates</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrQueryFramesPerBufferRangeBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrAudioSampleRateBD</type> <name>sampleRate</name></param> + <param><type>uint32_t</type>* <name>min</name></param> + <param><type>uint32_t</type>* <name>max</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAudioRendererBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialAudioRendererCreateInfoBD</type>* <name>createInfo</name></param> + <param><type>XrSpatialAudioRendererBD</type>* <name>renderer</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpatialAudioRendererBD</name></proto> + <param externsync="true_with_children"><type>XrSpatialAudioRendererBD</type> <name>renderer</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSoundObstacleMaterialBD</name></proto> + <param><type>XrSpatialAudioRendererBD</type> <name>renderer</name></param> + <param>const <type>XrSoundObstacleMaterialConfigBD</type>* <name>config</name></param> + <param><type>XrSoundObstacleMaterialBD</type>* <name>material</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUpdateSoundObstacleMaterialConfigBD</name></proto> + <param><type>XrSoundObstacleMaterialBD</type> <name>material</name></param> + <param>const <type>XrSoundObstacleMaterialConfigBD</type>* <name>config</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySoundObstacleMaterialBD</name></proto> + <param externsync="true_with_children"><type>XrSoundObstacleMaterialBD</type> <name>material</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSoundObstacleBD</name></proto> + <param><type>XrSpatialAudioRendererBD</type> <name>renderer</name></param> + <param>const <type>XrSoundObstacleConfigBD</type>* <name>config</name></param> + <param>const <type>XrSoundTriangleMeshBD</type>* <name>mesh</name></param> + <param><type>XrSoundObstacleBD</type>* <name>soundObstacle</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUpdateSoundObstacleConfigBD</name></proto> + <param><type>XrSoundObstacleBD</type> <name>soundObstacle</name></param> + <param optional="true">const <type>XrSoundObstacleConfigBD</type>* <name>config</name></param> + <param optional="true">const <type>XrSoundTriangleMeshBD</type>* <name>mesh</name></param> + <param><type>XrSoundObstacleFlagsBD</type> <name>flags</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySoundObstacleBD</name></proto> + <param externsync="true_with_children"><type>XrSoundObstacleBD</type> <name>soundObstacle</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSoundObjectBD</name></proto> + <param><type>XrSpatialAudioRendererBD</type> <name>renderer</name></param> + <param>const <type>XrSoundObjectConfigBD</type>* <name>config</name></param> + <param><type>XrSoundObjectBD</type>* <name>soundObject</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUpdateSoundObjectConfigBD</name></proto> + <param><type>XrSoundObjectBD</type> <name>soundObject</name></param> + <param>const <type>XrSoundObjectConfigBD</type>* <name>config</name></param> + <param><type>XrSoundObjectFlagsBD</type> <name>flags</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSubmitSoundObjectBufferBD</name></proto> + <param><type>XrSoundObjectBD</type> <name>soundObject</name></param> + <param>const <type>XrAudioBufferBD</type>* <name>buffer</name></param> + <implicitexternsyncparams> + <param>pname:soundObject parameter by any other flink:xrSubmitSoundObjectBufferBD call, as well as the pname:renderer parameter by any other flink:xrWaitAudioPeriodBD or flink:xrEndAudioPeriodBD call (if the pname:renderer is the parent of pname:soundObject)</param> + </implicitexternsyncparams> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySoundObjectBD</name></proto> + <param externsync="true_with_children"><type>XrSoundObjectBD</type> <name>soundObject</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSoundFieldBD</name></proto> + <param><type>XrSpatialAudioRendererBD</type> <name>renderer</name></param> + <param>const <type>XrSoundFieldConfigBD</type>* <name>config</name></param> + <param><type>XrSoundFieldBD</type>* <name>soundField</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUpdateSoundFieldConfigBD</name></proto> + <param><type>XrSoundFieldBD</type> <name>soundField</name></param> + <param optional="true">const <type>XrSoundFieldConfigBD</type>* <name>config</name></param> + <param><type>XrSoundFieldFlagsBD</type> <name>flags</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSubmitSoundFieldBufferBD</name></proto> + <param><type>XrSoundFieldBD</type> <name>soundField</name></param> + <param>const <type>XrAudioBufferBD</type>* <name>buffer</name></param> + <implicitexternsyncparams> + <param>pname:soundField parameter by any other flink:xrSubmitSoundFieldBufferBD call, as well as the pname:renderer parameter by any other flink:xrWaitAudioPeriodBD or flink:xrEndAudioPeriodBD call (if the pname:renderer is the parent of pname:soundField)</param> + </implicitexternsyncparams> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySoundFieldBD</name></proto> + <param externsync="true_with_children"><type>XrSoundFieldBD</type> <name>soundField</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING,XR_TIMEOUT_EXPIRED" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST"> + <proto><type>XrResult</type> <name>xrWaitAudioPeriodBD</name></proto> + <param><type>XrSpatialAudioRendererBD</type> <name>renderer</name></param> + <param><type>XrDuration</type> <name>timeout</name></param> + <implicitexternsyncparams> + <param>the pname:renderer parameter by any other flink:xrWaitAudioPeriodBD or flink:xrEndAudioPeriodBD call, pname:soundField parameter by any other flink:xrSubmitSoundFieldBufferBD call (if the pname:soundField is a child of the pname:renderer), and pname:soundObject parameter by any other flink:xrSubmitSoundObjectBufferBD call (if the pname:soundObject is a child of the pname:renderer)</param> + </implicitexternsyncparams> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST"> + <proto><type>XrResult</type> <name>xrEndAudioPeriodBD</name></proto> + <param><type>XrSpatialAudioRendererBD</type> <name>renderer</name></param> + <implicitexternsyncparams> + <param>the pname:renderer parameter by any other flink:xrWaitAudioPeriodBD or flink:xrEndAudioPeriodBD call, pname:soundField parameter by any other flink:xrSubmitSoundFieldBufferBD call (if the pname:soundField is a child of the pname:renderer), and pname:soundObject parameter by any other flink:xrSubmitSoundObjectBufferBD call (if the pname:soundObject is a child of the pname:renderer)</param> + </implicitexternsyncparams> + </command> + + <!-- commands for XR_BD_spatial_sensing --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_ENTITY_ID_INVALID_BD,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialEntityUuidBD</name></proto> + <param><type>XrSenseDataSnapshotBD</type> <name>snapshot</name></param> + <param><type>XrSpatialEntityIdBD</type> <name>entityId</name></param> + <param><type>XrUuidEXT</type>* <name>uuid</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_ENTITY_ID_INVALID_BD,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSpatialEntityComponentTypesBD</name></proto> + <param><type>XrSenseDataSnapshotBD</type> <name>snapshot</name></param> + <param><type>XrSpatialEntityIdBD</type> <name>entityId</name></param> + <param optional="true"><type>uint32_t</type> <name>componentTypeCapacityInput</name></param> + <param><type>uint32_t</type>* <name>componentTypeCountOutput</name></param> + <param optional="true" len="componentTypeCapacityInput"><type>XrSpatialEntityComponentTypeBD</type>* <name>componentTypes</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_ENTITY_ID_INVALID_BD,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialEntityComponentDataBD</name></proto> + <param><type>XrSenseDataSnapshotBD</type> <name>snapshot</name></param> + <param>const <type>XrSpatialEntityComponentGetInfoBD</type>* <name>getInfo</name></param> + <param><type>XrSpatialEntityComponentDataBaseHeaderBD</type>* <name>componentData</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSenseDataProviderBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSenseDataProviderCreateInfoBD</type>* <name>createInfo</name></param> + <param><type>XrSenseDataProviderBD</type>* <name>provider</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStartSenseDataProviderAsyncBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param>const <type>XrSenseDataProviderStartInfoBD</type>* <name>startInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStartSenseDataProviderCompleteBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrFutureCompletionEXT</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSenseDataProviderStateBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param><type>XrSenseDataProviderStateBD</type>* <name>state</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrQuerySenseDataAsyncBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param>const <type>XrSenseDataQueryInfoBD</type>* <name>queryInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrQuerySenseDataCompleteBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrSenseDataQueryCompletionBD</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD"> + <proto><type>XrResult</type> <name>xrDestroySenseDataSnapshotBD</name></proto> + <param externsync="true_with_children"><type>XrSenseDataSnapshotBD</type> <name>snapshot</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetQueriedSenseDataBD</name></proto> + <param><type>XrSenseDataSnapshotBD</type> <name>snapshot</name></param> + <param><type>XrQueriedSenseDataGetInfoBD</type>* <name>getInfo</name></param> + <param><type>XrQueriedSenseDataBD</type>* <name>queriedSenseData</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStopSenseDataProviderBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD"> + <proto><type>XrResult</type> <name>xrDestroySenseDataProviderBD</name></proto> + <param externsync="true_with_children"><type>XrSenseDataProviderBD</type> <name>provider</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialEntityAnchorBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param>const <type>XrSpatialEntityAnchorCreateInfoBD</type>* <name>createInfo</name></param> + <param><type>XrAnchorBD</type>* <name>anchor</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD"> + <proto><type>XrResult</type> <name>xrDestroyAnchorBD</name></proto> + <param externsync="true_with_children"><type>XrAnchorBD</type> <name>anchor</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetAnchorUuidBD</name></proto> + <param><type>XrAnchorBD</type> <name>anchor</name></param> + <param><type>XrUuidEXT</type>* <name>uuid</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateAnchorSpaceBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrAnchorSpaceCreateInfoBD</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>space</name></param> + </command> + + <!-- commands for XR_BD_spatial_anchor --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorAsyncBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param>const <type>XrSpatialAnchorCreateInfoBD</type>* <name>info</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorCompleteBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrSpatialAnchorCreateCompletionBD</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPersistSpatialAnchorAsyncBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param>const <type>XrSpatialAnchorPersistInfoBD</type>* <name>info</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPersistSpatialAnchorCompleteBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrFutureCompletionEXT</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUnpersistSpatialAnchorAsyncBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param>const <type>XrSpatialAnchorUnpersistInfoBD</type>* <name>info</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUnpersistSpatialAnchorCompleteBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrFutureCompletionEXT</type>* <name>completion</name></param> + </command> + + <!-- commands for XR_BD_spatial_anchor_sharing --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrShareSpatialAnchorAsyncBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param>const <type>XrSpatialAnchorShareInfoBD</type>* <name>info</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrShareSpatialAnchorCompleteBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrFutureCompletionEXT</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrDownloadSharedSpatialAnchorAsyncBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param>const <type>XrSharedSpatialAnchorDownloadInfoBD</type>* <name>info</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrDownloadSharedSpatialAnchorCompleteBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrFutureCompletionEXT</type>* <name>completion</name></param> + </command> + + <!-- commands for XR_BD_spatial_scene --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCaptureSceneAsyncBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param>const <type>XrSceneCaptureInfoBD</type>* <name>info</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCaptureSceneCompleteBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrFutureCompletionEXT</type>* <name>completion</name></param> + </command> + + <!-- commands for XR_BD_spatial_light_estimation --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateEnvironmentTextureResolutionsBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true"><type>uint32_t</type> <name>resolutionCapacityInput</name></param> + <param><type>uint32_t</type>* <name>resolutionCountOutput</name></param> + <param optional="true" len="resolutionCapacityInput"><type>XrEnvironmentTextureResolutionBD</type>* <name>resolutions</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateEnvironmentTexturePixelFormatsBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true"><type>uint32_t</type> <name>pixelFormatCapacityInput</name></param> + <param><type>uint32_t</type>* <name>pixelFormatCountOutput</name></param> + <param optional="true" len="pixelFormatCapacityInput"><type>XrEnvironmentTexturePixelFormatBD</type>* <name>pixelFormats</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateEnvironmentTextureTransferTypesBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true"><type>uint32_t</type> <name>transferTypeCapacityInput</name></param> + <param><type>uint32_t</type>* <name>transferTypeCountOutput</name></param> + <param optional="true" len="transferTypeCapacityInput"><type>XrEnvironmentTextureTransferTypeBD</type>* <name>transferTypes</name></param> + </command> + + <!-- XR_META_simultaneous_hands_and_controllers commands --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrResumeSimultaneousHandsAndControllersTrackingMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSimultaneousHandsAndControllersTrackingResumeInfoMETA</type>* <name>resumeInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPauseSimultaneousHandsAndControllersTrackingMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSimultaneousHandsAndControllersTrackingPauseInfoMETA</type>* <name>pauseInfo</name></param> + </command> + + <!-- commands for XR_BD_facial_simulation --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateFacialSimulationModesBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true"><type>uint32_t</type> <name>modeCapacityInput</name></param> + <param><type>uint32_t</type>* <name>modeCountOutput</name></param> + <param optional="true" len="modeCapacityInput"><type>XrFacialSimulationModeBD</type>* <name>modes</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateFaceTrackerBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrFaceTrackerCreateInfoBD</type>* <name>createInfo</name></param> + <param><type>XrFaceTrackerBD</type>* <name>tracker</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyFaceTrackerBD</name></proto> + <param externsync="true_with_children"><type>XrFaceTrackerBD</type> <name>tracker</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetFacialSimulationDataBD</name></proto> + <param><type>XrFaceTrackerBD</type> <name>tracker</name></param> + <param>const <type>XrFacialSimulationDataGetInfoBD</type>*<name>info</name></param> + <param><type>XrFacialSimulationDataBD</type>* <name>facialData</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetFacialSimulationModeBD</name></proto> + <param><type>XrFaceTrackerBD</type> <name>tracker</name></param> + <param><type>XrFacialSimulationModeBD</type> <name>mode</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetFacialSimulationModeBD</name></proto> + <param><type>XrFaceTrackerBD</type> <name>tracker</name></param> + <param><type>XrFacialSimulationModeBD</type>*<name>mode</name></param> + </command> + + <!-- XR_ANDROID_geospatial --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateGeospatialTrackerANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrGeospatialTrackerCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrGeospatialTrackerANDROID</type>* <name>geospatialTrackerOutput</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyGeospatialTrackerANDROID</name></proto> + <param externsync="true_with_children"><type>XrGeospatialTrackerANDROID</type> <name>geospatialTracker</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_GEOSPATIAL_TRACKER_NOT_RUNNING_ANDROID,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrLocateGeospatialPoseFromPoseANDROID</name></proto> + <param><type>XrGeospatialTrackerANDROID</type> <name>geospatialTracker</name></param> + <param>const <type>XrGeospatialPoseFromPoseLocateInfoANDROID</type>* <name>locateInfo</name></param> + <param><type>XrGeospatialPoseResultANDROID</type>* <name>geospatialPoseResult</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_GEOSPATIAL_COORDINATES_INVALID_ANDROID,XR_ERROR_GEOSPATIAL_TRACKER_NOT_RUNNING_ANDROID,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrLocateGeospatialPoseANDROID</name></proto> + <param><type>XrGeospatialTrackerANDROID</type> <name>geospatialTracker</name></param> + <param>const <type>XrGeospatialPoseLocateInfoANDROID</type>* <name>locateInfo</name></param> + <param><type>XrSpaceLocation</type>* <name>location</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_GEOSPATIAL_COORDINATES_INVALID_ANDROID,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCheckVpsAvailabilityAsyncANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>double</type> <name>latitude</name></param> + <param><type>double</type> <name>longitude</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCheckVpsAvailabilityCompleteANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrVPSAvailabilityCheckCompletionANDROID</type>* <name>completion</name></param> + </command> + + <!-- XR_ANDROID_geospatial_anchor --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_GEOSPATIAL_COORDINATES_INVALID_ANDROID,XR_ERROR_GEOSPATIAL_TRACKER_NOT_RUNNING_ANDROID,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateGeospatialAnchorANDROID</name></proto> + <param><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + <param>const <type>XrGeospatialAnchorCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrSpatialEntityIdEXT</type>* <name>anchorEntityId</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_GEOSPATIAL_COORDINATES_INVALID_ANDROID,XR_ERROR_GEOSPATIAL_TRACKER_NOT_RUNNING_ANDROID,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSurfaceAnchorAsyncANDROID</name></proto> + <param><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + <param>const <type>XrSurfaceAnchorCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSurfaceAnchorCompleteANDROID</name></proto> + <param><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrSurfaceAnchorCreateCompletionANDROID</type>* <name>completion</name></param> + </command> + + <!-- XR_ANDROID_trackables_image --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_IMAGE_FORMAT_UNSUPPORTED_ANDROID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateTrackableImageDatabaseAsyncANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrTrackableImageDatabaseCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateTrackableImageDatabaseCompleteANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrCreateTrackableImageDatabaseCompletionANDROID</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyTrackableImageDatabaseANDROID</name></proto> + <param externsync="true_with_children"><type>XrTrackableImageDatabaseANDROID</type> <name>database</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrAddTrackableImageDatabaseANDROID</name></proto> + <param><type>XrTrackableTrackerANDROID</type> <name>tracker</name></param> + <param><type>XrTrackableImageDatabaseANDROID</type> <name>database</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRemoveTrackableImageDatabaseANDROID</name></proto> + <param><type>XrTrackableTrackerANDROID</type> <name>tracker</name></param> + <param><type>XrTrackableImageDatabaseANDROID</type> <name>database</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_MISMATCHING_TRACKABLE_TYPE_ANDROID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetTrackableImageANDROID</name></proto> + <param><type>XrTrackableTrackerANDROID</type> <name>tracker</name></param> + <param>const <type>XrTrackableGetInfoANDROID</type>* <name>getInfo</name></param> + <param><type>XrTrackableImageANDROID</type>* <name>trackable</name></param> + </command> + + <!-- XR_ANDROID_spatial_entity_bound_anchor --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSpatialAnchorAttachableComponentsANDROID</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param optional="true"><type>uint32_t</type> <name>attachableComponentCapacityInput</name></param> + <param><type>uint32_t</type>* <name>attachableComponentCountOutput</name></param> + <param optional="true" len="attachableComponentCapacityInput"><type>XrSpatialComponentTypeEXT</type>* <name>attachableComponents</name></param> + </command> + + <!-- XR_ANDROID_spatial_anchor_space --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_ANCHOR_ATTACHABLE_COMPONENT_NOT_FOUND_ANDROID,XR_ERROR_SPATIAL_ENTITY_ID_INVALID_EXT,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorSpaceANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + <param>const <type>XrSpatialAnchorCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrSpatialEntityIdEXT</type>* <name>anchorEntityId</name></param> + <param><type>XrSpace</type>* <name>anchorSpace</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_ANCHOR_ENTITY_ID_INVALID_ANDROID,XR_ERROR_SPATIAL_ENTITY_ID_INVALID_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorSpaceFromIdANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + <param>const <type>XrSpatialAnchorSpaceFromIdCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>anchorSpace</name></param> + </command> + + <!-- XR_ANDROID_google_cloud_auth --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_KEYLESS_AUTH_NOT_SETUP_ANDROID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetGoogleCloudAuthAsyncANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrGoogleCloudAuthInfoBaseHeaderANDROID</type>* <name>authInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetGoogleCloudAuthCompleteANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrFutureCompletionEXT</type>* <name>completion</name></param> + </command> + + <!-- XR_META_tile_properties_hint commands --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetTilePropertiesHintMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrTilePropertiesHintMETA</type>* <name>properties</name></param> + </command> + + <!-- XR_META_environment_raycast --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateEnvironmentRaycasterAsyncMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true">const <type>XrEnvironmentRaycasterCreateInfoMETA</type>* <name>info</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INITIALIZATION_FAILED,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateEnvironmentRaycasterCompleteMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrEnvironmentRaycasterCreateCompletionMETA</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyEnvironmentRaycasterMETA</name></proto> + <param externsync="true_with_children"><type>XrEnvironmentRaycasterMETA</type> <name>environmentRaycaster</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPerformEnvironmentRaycastMETA</name></proto> + <param><type>XrEnvironmentRaycasterMETA</type> <name>environmentRaycaster</name></param> + <param>const <type>XrEnvironmentRaycastHitGetInfoMETA</type>* <name>info</name></param> + <param><type>XrEnvironmentRaycastHitMETA</type>* <name>hitPoint</name></param> + </command> + + <!-- XR_ANDROID_spatial_discovery_raycast commands --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_COMPONENT_NOT_ENABLED_EXT,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialRaycastSnapshotANDROID</name></proto> + <param><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + <param>const <type>XrSpatialRaycastSnapshotCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrSpatialSnapshotEXT</type>* <name>snapshot</name></param> + </command> + + <!-- XR_QCOM_hand_tracking_gesture --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID"> + <proto><type>XrResult</type> <name>xrGetHandGestureQCOM</name></proto> + <param><type>XrHandTrackerEXT</type> <name>handTracker</name></param> + <param><type>XrTime</type> <name>time</name></param> + <param><type>XrHandGestureQCOM</type>* <name>handGesture</name></param> + </command> + + <!-- XR_META_hand_tracking_frequency --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetHandTrackingFrequencyHintMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrHandTrackingFrequencyHintMETA</type> <name>frequencyHint</name></param> + </command> + + <!-- XR_EXT_haptic_parametric --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_ACTION_TYPE_MISMATCH,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrHapticParametricGetPropertiesEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrHapticActionInfo</type>* <name>hapticActionInfo</name></param> + <param><type>XrHapticParametricPropertiesEXT</type>* <name>parametricProperties</name></param> + </command> + + <!-- XR_SONY_swapchain_color_space --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateColorSpacesSONY</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrColorSpacesEnumerateInfoSONY</type>* <name>enumerateInfo</name></param> + <param optional="true"><type>uint32_t</type> <name>colorSpaceCapacityInput</name></param> + <param><type>uint32_t</type>* <name>colorSpaceCountOutput</name></param> + <param optional="true" len="colorSpaceCapacityInput"><type>XrColorSpaceSONY</type>* <name>colorSpaces</name></param> + </command> + + <!-- XR_BD_camera_image commands --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateAvailableCamerasBD</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrAvailableCamerasEnumerateInfoBD</type>* <name>enumerateInfo</name></param> + <param optional="true"><type>uint32_t</type> <name>cameraCapacityInput</name></param> + <param><type>uint32_t</type>* <name>cameraCountOutput</name></param> + <param len="cameraCapacityInput" optional="true"><type>XrAvailableCameraBD</type>* <name>cameras</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_CAMERA_ID_INVALID_BD,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateCameraPropertyTypesBD</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrCameraPropertyTypesEnumerateInfoBD</type>* <name>enumerateInfo</name></param> + <param><type>XrCameraPropertyTypesBD</type>* <name>propertyTypes</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_CAMERA_ID_INVALID_BD,XR_ERROR_CAMERA_PROPERTY_TYPE_INVALID_BD,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetCameraPropertiesBD</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrCameraPropertiesGetInfoBD</type>* <name>getInfo</name></param> + <param><type>XrCameraPropertiesBD</type>* <name>properties</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_CAMERA_ID_INVALID_BD,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateCameraCapabilityTypesBD</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrCameraCapabilityTypesEnumerateInfoBD</type>* <name>enumerateInfo</name></param> + <param><type>XrCameraCapabilityTypesBD</type>* <name>capabilityTypes</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_CAMERA_CAPABILITY_TYPE_INVALID_BD,XR_ERROR_CAMERA_ID_INVALID_BD,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetCameraSupportedCapabilitiesBD</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrCameraSupportedCapabilitiesGetInfoBD</type>* <name>getInfo</name></param> + <param><type>XrCameraSupportedCapabilitiesBD</type>* <name>capabilities</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_CAMERA_ID_INVALID_BD,XR_ERROR_CAMERA_OCCUPIED_BD,XR_ERROR_CAMERA_UNAVAILABLE_BD,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateCameraDeviceAsyncBD</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrCameraDeviceCreateInfoBD</type>* <name>createInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateCameraDeviceCompleteBD</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrCreateCameraDeviceCompletionBD</type>* <name>completion</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyCameraDeviceBD</name></proto> + <param externsync="true_with_children"><type>XrCameraDeviceBD</type> <name>device</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CAMERA_ID_INVALID_BD,XR_ERROR_CAMERA_OCCUPIED_BD,XR_ERROR_CAMERA_UNAVAILABLE_BD,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateCameraCaptureSessionAsyncBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrCameraCaptureSessionCreateInfoBD</type>* <name>createInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CAMERA_OCCUPIED_BD,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateCameraCaptureSessionCompleteBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrCreateCameraCaptureSessionCompletionBD</type>* <name>completion</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyCameraCaptureSessionBD</name></proto> + <param externsync="true_with_children"><type>XrCameraCaptureSessionBD</type> <name>captureSession</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_CAMERA_CAPTURE_SESSION_CAPTURING_BD,XR_ERROR_CAMERA_OCCUPIED_BD,XR_ERROR_CAMERA_UNAVAILABLE_BD,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrBeginCameraCaptureBD</name></proto> + <param><type>XrCameraCaptureSessionBD</type> <name>captureSession</name></param> + <param>const <type>XrCameraCaptureBeginInfoBD</type>* <name>beginInfo</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_CAMERA_CAPTURE_SESSION_NOT_CAPTURING_BD,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEndCameraCaptureBD</name></proto> + <param><type>XrCameraCaptureSessionBD</type> <name>captureSession</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_CAMERA_CAPTURE_SESSION_NOT_CAPTURING_BD,XR_ERROR_CAMERA_OCCUPIED_BD,XR_ERROR_CAMERA_UNAVAILABLE_BD,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_IMAGE_BUFFER_EXHAUSTED_BD,XR_ERROR_INSTANCE_LOST,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrAcquireCameraImageBD</name></proto> + <param><type>XrCameraCaptureSessionBD</type> <name>captureSession</name></param> + <param>const <type>XrCameraImageAcquireInfoBD</type>* <name>acquireInfo</name></param> + <param><type>XrCameraImageBD</type>* <name>image</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_CAMERA_IMAGE_ID_INVALID_BD,XR_ERROR_CAMERA_UNAVAILABLE_BD,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetCameraImageDataBD</name></proto> + <param><type>XrCameraCaptureSessionBD</type> <name>captureSession</name></param> + <param><type>XrCameraImageIdBD</type> <name>imageId</name></param> + <param><type>XrCameraImageDataBaseHeaderBD</type>* <name>imageData</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_CAMERA_IMAGE_ID_INVALID_BD,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrReleaseCameraImageBD</name></proto> + <param><type>XrCameraCaptureSessionBD</type> <name>captureSession</name></param> + <param><type>XrCameraImageIdBD</type> <name>imageId</name></param> + </command> + + <!-- XR_SONY_hdr_metadata --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetHdrMetadataSONY</name></proto> + <param><type>XrSwapchain</type> <name>swapchain</name></param> + <param>const <type>XrHdrMetadataSONY</type>* <name>hdrMetadata</name></param> + </command> + + </commands> + + <interaction_profiles> + <interaction_profile name="/interaction_profiles/khr/simple_controller" title="Khronos Simple Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/select/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <interaction_profile name="/interaction_profiles/google/daydream_controller" title="Google Daydream Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/select/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/trackpad/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </interaction_profile> + + <interaction_profile name="/interaction_profiles/htc/vive_controller" title="HTC Vive Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/trackpad/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <interaction_profile name="/interaction_profiles/htc/vive_pro" title="HTC Vive Pro"> + <user_path path="/user/head"/> + <component subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/volume_up/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/volume_down/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/mute_mic/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </interaction_profile> + + <interaction_profile name="/interaction_profiles/microsoft/motion_controller" title="Microsoft Mixed Reality Motion Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/trackpad/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <interaction_profile name="/interaction_profiles/microsoft/xbox_controller" title="Microsoft Xbox Controller"> + <user_path path="/user/gamepad"/> + <component subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/view/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/dpad_down/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/dpad_right/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/dpad_up/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/dpad_left/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/shoulder_left/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/shoulder_right/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick_left/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick_right/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger_left/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger_right/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick_left" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick_left/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick_left/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick_right" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick_right/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick_right/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/output/haptic_left" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + <component subpath="/output/haptic_right" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + <component subpath="/output/haptic_left_trigger" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + <component subpath="/output/haptic_right_trigger" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + + <interaction_profile name="/interaction_profiles/oculus/go_controller" title="Oculus Go Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/back/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/trackpad/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </interaction_profile> + + <interaction_profile name="/interaction_profiles/oculus/touch_controller" title="Oculus Touch Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbrest/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <interaction_profile name="/interaction_profiles/valve/index_controller" title="Valve Index Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/system/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/squeeze/force" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/trackpad/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/force" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_EXT_eye_gaze_interaction --> + + <interaction_profile name="/interaction_profiles/ext/eye_gaze_interaction" title="Multivendor eye gaze interaction"> + <user_path path="/user/eyes_ext"/> + <component subpath="/input/gaze_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </interaction_profile> + + <!-- XR_MSFT_hand_interaction --> + + <interaction_profile name="/interaction_profiles/microsoft/hand_interaction" title="Microsoft hand interaction"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/select/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </interaction_profile> + + <!-- XR_HUAWEI_controller_interaction --> + + <interaction_profile name="/interaction_profiles/huawei/controller" title="Huawei Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/home/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/back/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/volume_up/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/volume_down/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/trackpad/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_HTC_hand_interaction --> + + <interaction_profile name="/interaction_profiles/htc/hand_interaction" title="HTC hand interaction"> + <user_path path="/user/hand_htc/left"/> + <user_path path="/user/hand_htc/right"/> + <component subpath="/input/select/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </interaction_profile> + + <!-- XR_HTC_vive_wrist_tracker_interaction --> + + <interaction_profile name="/interaction_profiles/htc/vive_wrist_tracker" title="HTC VIVE Wrist Tracker"> + <user_path path="/user/wrist_htc/left"/> + <user_path path="/user/wrist_htc/right"/> + <component user_path="/user/wrist_htc/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/wrist_htc/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/wrist_htc/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/wrist_htc/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/entity_htc/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </interaction_profile> + + <!-- XR_HTC_vive_cosmos_controller_interaction --> + + <interaction_profile name="/interaction_profiles/htc/vive_cosmos_controller" title="HTC VIVE Cosmos Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + + <component subpath="/input/shoulder/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_HTC_vive_focus3_controller_interaction --> + + <interaction_profile name="/interaction_profiles/htc/vive_focus3_controller" title="HTC VIVE Focus 3 Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + + <component subpath="/input/squeeze/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbrest/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_HTCX_vive_tracker_interaction --> + + <interaction_profile name="/interaction_profiles/htc/vive_tracker_htcx" title="HTC VIVE Tracker"> + <user_path path="/user/vive_tracker_htcx/role/handheld_object"/> + <user_path path="/user/vive_tracker_htcx/role/left_foot"/> + <user_path path="/user/vive_tracker_htcx/role/right_foot"/> + <user_path path="/user/vive_tracker_htcx/role/left_shoulder"/> + <user_path path="/user/vive_tracker_htcx/role/right_shoulder"/> + <user_path path="/user/vive_tracker_htcx/role/left_elbow"/> + <user_path path="/user/vive_tracker_htcx/role/right_elbow"/> + <user_path path="/user/vive_tracker_htcx/role/left_knee"/> + <user_path path="/user/vive_tracker_htcx/role/right_knee"/> + <user_path path="/user/vive_tracker_htcx/role/left_wrist"/> + <user_path path="/user/vive_tracker_htcx/role/right_wrist"/> + <user_path path="/user/vive_tracker_htcx/role/left_ankle"/> + <user_path path="/user/vive_tracker_htcx/role/right_ankle"/> + <user_path path="/user/vive_tracker_htcx/role/waist"/> + <user_path path="/user/vive_tracker_htcx/role/chest"/> + <user_path path="/user/vive_tracker_htcx/role/camera"/> + <user_path path="/user/vive_tracker_htcx/role/keyboard"/> + + <component subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/trackpad/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_EXT_samsung_odyssey_controller --> + + <interaction_profile name="/interaction_profiles/samsung/odyssey_controller" title="Samsung Odyssey Mixed Reality Motion Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/trackpad/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_EXT_hp_mixed_reality_controller --> + + <interaction_profile name="/interaction_profiles/hp/mixed_reality_controller" title="HP Mixed Reality Motion Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_ML_ml2_controller_interaction --> + + <interaction_profile name="/interaction_profiles/ml/ml2_controller" title="Magic Leap 2 Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/home/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/trackpad/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/force" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/shoulder/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_FB_touch_pro_controller --> + <interaction_profile name="/interaction_profiles/facebook/touch_controller_pro" title="Meta Quest Touch Pro Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbrest/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + <component subpath="/input/thumbrest/force" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/stylus_fb/force" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/curl_fb" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/slide_fb" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumb_fb/proximity_fb" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/proximity_fb" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/output/haptic_trigger_fb" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + <component subpath="/output/haptic_thumb_fb" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_META_touch_controller_plus --> + <interaction_profile name="/interaction_profiles/meta/touch_controller_plus" title="Meta Quest Touch Plus Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbrest/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + <component subpath="/input/thumb_meta/proximity_meta" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/proximity_meta" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/curl_meta" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/slide_meta" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/force" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + </interaction_profile> + + <!-- 1.1 Meta Interaction Profiles --> + <!-- Promoted and renamed --> + <interaction_profile name="/interaction_profiles/meta/touch_pro_controller" title="Meta Quest Touch Pro Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbrest/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + <component subpath="/input/thumbrest/force" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/stylus/force" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumb_resting_surfaces/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger_curl/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger_slide/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/output/haptic_trigger" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + <component subpath="/output/haptic_thumb" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- Promoted and renamed --> + <interaction_profile name="/interaction_profiles/meta/touch_plus_controller" title="Meta Quest Touch Plus Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbrest/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + <component subpath="/input/thumb_resting_surfaces/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger_curl/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger_slide/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/force" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + </interaction_profile> + + <!-- New legacy profile --> + <interaction_profile name="/interaction_profiles/meta/touch_controller_rift_cv1" title="Rift CV1 Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumb_resting_surfaces/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbrest/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- New legacy profile --> + <interaction_profile name="/interaction_profiles/meta/touch_controller_quest_1_rift_s" title="Quest / Rift S Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumb_resting_surfaces/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- New legacy profile --> + <interaction_profile name="/interaction_profiles/meta/touch_controller_quest_2" title="Quest 2 Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumb_resting_surfaces/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbrest/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + <!-- (END) 1.1 Meta Interaction Profiles --> + + + <!-- XR_BD_controller_interaction --> + + <interaction_profile name="/interaction_profiles/bytedance/pico_neo3_controller" title="ByteDance PICO Neo3 Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <interaction_profile name="/interaction_profiles/bytedance/pico4_controller" title="ByteDance PICO 4 Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <interaction_profile name="/interaction_profiles/bytedance/pico_g3_controller" title="ByteDance PICO G3 Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </interaction_profile> + + <interaction_profile name="/interaction_profiles/bytedance/pico_ultra_controller_bd" title="PICO Ultra Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + + <!-- XR_EXT_hand_interaction --> + <interaction_profile name="/interaction_profiles/ext/hand_interaction_ext" title="EXT hand interaction profile"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/pinch_ext/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/pinch_ext/ready_ext" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grasp_ext/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/grasp_ext/ready_ext" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/aim_activate_ext/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/aim_activate_ext/ready_ext" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </interaction_profile> + + <!-- XR_ANDROID_mouse_interaction --> + <interaction_profile name="/interaction_profiles/android/mouse_interaction_android" title="ANDROID mouse interaction profile"> + <user_path path="/user/mouse"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/select/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/secondary_android/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/tertiary_android/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/scroll_android/value" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + </interaction_profile> + + <!-- XR_OPPO_controller_interaction --> + <interaction_profile name="/interaction_profiles/oppo/mr_controller_oppo" title="OPPO MR Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/heartrate_oppo/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/home/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_YVR_controller_interaction --> + <interaction_profile name="/interaction_profiles/yvr/touch_controller_yvr" title="YVR Touch Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_VARJO_xr4_controller_interaction --> + <interaction_profile name="/interaction_profiles/varjo/xr-4_controller" title="Varjo XR-4 Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_LOGITECH_mx_ink_stylus_interaction --> + <interaction_profile name="/interaction_profiles/logitech/mx_ink_stylus_logitech" title="Logitech MX Ink Stylus"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/tip_logitech/force" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/cluster_middle_logitech/force" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/cluster_front_logitech/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/cluster_front_logitech/double_tap_logitech" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/cluster_back_logitech/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/cluster_back_logitech/double_tap_logitech" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/dock_logitech/docked_logitech" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/tip_logitech/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_KHR_generic_controller --> + <interaction_profile name="/interaction_profiles/khr/generic_controller" title="Khronos Generic Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/primary/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/secondary/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + </interaction_profiles> + + <!-- SECTION: OpenXR 1.0 API interface definitions --> + <feature api="openxr" name="XR_VERSION_1_0" number="1.0"> + <require comment="Header boilerplate"> + <type name="openxr_platform_defines"/> + </require> + <require comment="API version"> + <type name="XR_CURRENT_API_VERSION"/> + <type name="XR_API_VERSION_1_0"/> + <type name="XR_VERSION_MAJOR"/> + <type name="XR_VERSION_MINOR"/> + <type name="XR_VERSION_PATCH"/> + <type name="XrVersion"/> + </require> + <require comment="API constants"> + <enum name="XR_TRUE"/> + <enum name="XR_FALSE"/> + <enum name="XR_MAX_EXTENSION_NAME_SIZE"/> + <enum name="XR_MAX_API_LAYER_NAME_SIZE"/> + <enum name="XR_MAX_API_LAYER_DESCRIPTION_SIZE"/> + <enum name="XR_MAX_SYSTEM_NAME_SIZE"/> + <enum name="XR_MAX_APPLICATION_NAME_SIZE"/> + <enum name="XR_MAX_ENGINE_NAME_SIZE"/> + <enum name="XR_MAX_RUNTIME_NAME_SIZE"/> + <enum name="XR_MAX_PATH_LENGTH"/> + <enum name="XR_MAX_STRUCTURE_NAME_SIZE"/> + <enum name="XR_MAX_RESULT_STRING_SIZE"/> + <type name="XR_MIN_COMPOSITION_LAYERS_SUPPORTED"/> + <type name="XR_NULL_HANDLE"/> + <type name="XR_NULL_SYSTEM_ID"/> + <type name="XR_NULL_PATH"/> + <type name="XR_SUCCEEDED"/> + <type name="XR_FAILED"/> + <type name="XR_UNQUALIFIED_SUCCESS"/> + <type name="XR_NO_DURATION"/> + <type name="XR_INFINITE_DURATION"/> + <type name="XR_MIN_HAPTIC_DURATION"/> + <type name="XR_FREQUENCY_UNSPECIFIED"/> + <type name="XR_MAX_EVENT_DATA_SIZE"/> + <type name="XR_EXTENSION_ENUM_BASE"/> + <type name="XR_EXTENSION_ENUM_STRIDE"/> + </require> + <require comment="API macros"> + <type name="XR_MAY_ALIAS"/> + <type name="XR_DEFINE_HANDLE"/> + <type name="XR_DEFINE_OPAQUE_64"/> + + <type name="XR_DEFINE_ATOM"/> + <type name="XR_MAKE_VERSION"/> + </require> + <require comment="Result"> + <type name="XrResult"/> + </require> + <require comment="Instance"> + <command name="xrGetInstanceProcAddr"/> + <command name="xrEnumerateApiLayerProperties"/> + <command name="xrEnumerateInstanceExtensionProperties"/> + <command name="xrCreateInstance"/> + <command name="xrDestroyInstance"/> + <command name="xrGetInstanceProperties"/> + <command name="xrPollEvent"/> + <command name="xrResultToString"/> + <command name="xrStructureTypeToString"/> + + <type name="PFN_xrVoidFunction"/> + <type name="XrApiLayerProperties"/> + <type name="XrExtensionProperties"/> + <type name="XrInstance"/> + <type name="XrInstanceCreateInfo"/> + <type name="XrInstanceCreateFlags"/> + <type name="XrInstanceCreateFlagBits"/> + <type name="XrApplicationInfo"/> + <type name="XrInstanceProperties"/> + <type name="XrEventDataBuffer"/> + <type name="XrStructureType"/> + </require> + <require comment="Device"> + <command name="xrGetSystem"/> + <command name="xrGetSystemProperties"/> + <command name="xrEnumerateEnvironmentBlendModes"/> + <command name="xrCreateSession"/> + <command name="xrDestroySession"/> + + <type name="XrSystemId"/> + <type name="XrFormFactor"/> + <type name="XrSystemGetInfo"/> + <type name="XrSystemProperties"/> + <type name="XrSystemGraphicsProperties"/> + <type name="XrSystemTrackingProperties"/> + <type name="XrEnvironmentBlendMode"/> + <type name="XrSession"/> + <type name="XrSessionCreateInfo"/> + <type name="XrSessionCreateFlags"/> + <type name="XrSessionCreateFlagBits"/> + </require> + <require comment="Space"> + <command name="xrEnumerateReferenceSpaces"/> + <command name="xrCreateReferenceSpace"/> + <command name="xrGetReferenceSpaceBoundsRect"/> + <command name="xrCreateActionSpace"/> + <command name="xrLocateSpace"/> + <command name="xrDestroySpace"/> + + <type name="XrSpace"/> + <type name="XrReferenceSpaceCreateInfo"/> + <type name="XrReferenceSpaceType"/> + <type name="XrActionSpaceCreateInfo"/> + <type name="XrSpaceLocation"/> + <type name="XrSpaceLocationFlags"/> + <type name="XrSpaceLocationFlagBits"/> + <type name="XrSpaceVelocity"/> + <type name="XrSpaceVelocityFlags"/> + <type name="XrSpaceVelocityFlagBits"/> + <type name="XrPosef"/> + <type name="XrVector3f"/> + <type name="XrQuaternionf"/> + </require> + <require comment="ViewConfigurations"> + <command name="xrEnumerateViewConfigurations"/> + <command name="xrGetViewConfigurationProperties"/> + <command name="xrEnumerateViewConfigurationViews"/> + + <type name="XrViewConfigurationType"/> + <type name="XrViewConfigurationProperties"/> + <type name="XrViewConfigurationView"/> + </require> + <require comment="Image"> + <command name="xrEnumerateSwapchainFormats"/> + <command name="xrCreateSwapchain"/> + <command name="xrDestroySwapchain"/> + <command name="xrEnumerateSwapchainImages"/> + <command name="xrAcquireSwapchainImage"/> + <command name="xrWaitSwapchainImage"/> + <command name="xrReleaseSwapchainImage"/> + + <type name="XrSwapchain"/> + <type name="XrSwapchainCreateInfo"/> + <type name="XrSwapchainCreateFlags"/> + <type name="XrSwapchainCreateFlagBits"/> + <type name="XrSwapchainUsageFlags"/> + <type name="XrSwapchainUsageFlagBits"/> + <type name="XrSwapchainImageBaseHeader"/> + <type name="XrSwapchainImageAcquireInfo"/> + <type name="XrSwapchainImageWaitInfo"/> + <type name="XrDuration"/> + <type name="XrSwapchainImageReleaseInfo"/> + </require> + <require comment="Session"> + <command name="xrBeginSession"/> + <command name="xrEndSession"/> + <command name="xrRequestExitSession"/> + <type name="XrSessionBeginInfo"/> + </require> + <require comment="Display Timing"> + <command name="xrWaitFrame"/> + <command name="xrBeginFrame"/> + <command name="xrEndFrame"/> + <command name="xrLocateViews"/> + + <type name="XrFrameState"/> + <type name="XrFrameWaitInfo"/> + <type name="XrFrameBeginInfo"/> + <type name="XrFrameEndInfo"/> + <type name="XrCompositionLayerBaseHeader"/> + <type name="XrCompositionLayerFlags"/> + <type name="XrCompositionLayerFlagBits"/> + <type name="XrEyeVisibility"/> + <type name="XrViewState"/> + <type name="XrViewStateFlags"/> + <type name="XrViewStateFlagBits"/> + <type name="XrViewLocateInfo"/> + <type name="XrTime"/> + <type name="XrView"/> + <type name="XrFovf"/> + </require> + <require comment="Semantic Paths"> + <command name="xrStringToPath"/> + <command name="xrPathToString"/> + + <type name="XrPath"/> + + <interaction_profile name="/interaction_profiles/khr/simple_controller"/> + <interaction_profile name="/interaction_profiles/google/daydream_controller"/> + <interaction_profile name="/interaction_profiles/htc/vive_controller"/> + <interaction_profile name="/interaction_profiles/htc/vive_pro"/> + <interaction_profile name="/interaction_profiles/microsoft/motion_controller"/> + <interaction_profile name="/interaction_profiles/microsoft/xbox_controller"/> + <interaction_profile name="/interaction_profiles/oculus/go_controller"/> + <interaction_profile name="/interaction_profiles/oculus/touch_controller"/> + <interaction_profile name="/interaction_profiles/valve/index_controller"/> + </require> + <require comment="Input"> + <command name="xrCreateActionSet"/> + <command name="xrDestroyActionSet"/> + <command name="xrCreateAction"/> + <command name="xrDestroyAction"/> + <command name="xrSuggestInteractionProfileBindings"/> + <command name="xrAttachSessionActionSets"/> + <command name="xrGetCurrentInteractionProfile"/> + <command name="xrGetActionStateBoolean"/> + <command name="xrGetActionStateFloat"/> + <command name="xrGetActionStateVector2f"/> + <command name="xrGetActionStatePose"/> + <command name="xrSyncActions"/> + <command name="xrEnumerateBoundSourcesForAction"/> + <command name="xrGetInputSourceLocalizedName"/> + + <type name="XrActionSet"/> + <type name="XrActionSetCreateInfo"/> + <type name="XrAction"/> + <type name="XrActionCreateInfo"/> + <type name="XrActionType"/> + <type name="XrInteractionProfileSuggestedBinding"/> + <type name="XrActionSuggestedBinding"/> + <type name="XrSessionActionSetsAttachInfo"/> + <type name="XrInteractionProfileState"/> + <type name="XrActionStateGetInfo"/> + <type name="XrActionStateBoolean"/> + <type name="XrActionStateFloat"/> + <type name="XrActionStateVector2f"/> + <type name="XrVector2f"/> + <type name="XrActionStatePose"/> + <type name="XrActionsSyncInfo"/> + <type name="XrActiveActionSet"/> + <type name="XrBoundSourcesForActionEnumerateInfo"/> + <type name="XrInputSourceLocalizedNameGetInfo"/> + <type name="XrInputSourceLocalizedNameFlags"/> + <type name="XrInputSourceLocalizedNameFlagBits"/> + </require> + <require comment="Haptics"> + <command name="xrApplyHapticFeedback"/> + <command name="xrStopHapticFeedback"/> + + <type name="XrHapticBaseHeader"/> + <type name="XrHapticActionInfo"/> + </require> + <require comment="Types not directly used by the API"> + <!-- Include <type name="typename"/> here for e.g. structs that + are not parameter types of functions, but still need to be + defined in the API. + --> + <type name="XrFlags64"/> + <type name="XrBool32"/> + + <!-- Utility types to handle polymorphism --> + <type name="XrBaseInStructure"/> + <type name="XrBaseOutStructure"/> + + <!-- Composition layer types used polymorphically by the core spec through XrCompositionLayerBaseHeader. --> + <type name="XrCompositionLayerProjection"/> + <type name="XrCompositionLayerProjectionView"/> + <type name="XrCompositionLayerQuad"/> + + <type name="XrSwapchainSubImage"/> + <type name="XrRect2Di"/> + <type name="XrOffset2Di"/> + <type name="XrExtent2Di"/> + + <!-- Event data types used polymorphically by the core spec through XrEventDataBaseHeader --> + <type name="XrEventDataBaseHeader"/> + <type name="XrEventDataEventsLost"/> + <type name="XrEventDataInstanceLossPending"/> + <type name="XrEventDataSessionStateChanged"/> + <type name="XrEventDataReferenceSpaceChangePending"/> + <type name="XrEventDataInteractionProfileChanged"/> + <type name="XrSessionState"/> + + <!-- Haptic data type used polymorphically by the core spec via XrHapticBaseHeader --> + <type name="XrHapticVibration"/> + + <!-- Unused, but documented types, included for completeness and regularity. --> + <type name="XrOffset2Df"/> + <type name="XrRect2Df"/> + <type name="XrVector4f"/> + + + <!-- Core-like basic data types, documented in core spec, though currently only used by KHR extensions: --> + + <!-- used in XR_KHR_composition_layer_color_scale_bias --> + <type name="XrColor4f"/> + <!-- used in XR_KHR_space bounds --> + <type name="XrExtent2Df"/> + <!-- used in XR_EXT_debug_utils --> + <type name="XrObjectType"/> + </require> + </feature> + + <!-- SECTION: OpenXR Loader API interface definitions --> + <feature api="openxr" name="XR_LOADER_VERSION_1_0" number="1.0"> + <require comment="Negotiate"> + <type name="XR_CURRENT_LOADER_API_LAYER_VERSION"/> + <type name="XR_CURRENT_LOADER_RUNTIME_VERSION"/> + <type name="XR_LOADER_INFO_STRUCT_VERSION"/> + <type name="XR_API_LAYER_INFO_STRUCT_VERSION"/> + <type name="XR_RUNTIME_INFO_STRUCT_VERSION"/> + <type name="XR_API_LAYER_NEXT_INFO_STRUCT_VERSION"/> + <type name="XR_API_LAYER_CREATE_INFO_STRUCT_VERSION"/> + <type name="XR_API_LAYER_MAX_SETTINGS_PATH_SIZE"/> + + <command name="xrCreateApiLayerInstance"/> + <command name="xrNegotiateLoaderRuntimeInterface"/> + <command name="xrNegotiateLoaderApiLayerInterface"/> + + <type name="PFN_xrGetInstanceProcAddr"/> + <type name="PFN_xrCreateApiLayerInstance"/> + <type name="XrLoaderInterfaceStructs"/> + <type name="XrApiLayerCreateInfo"/> + <type name="XrApiLayerNextInfo"/> + <type name="XrNegotiateApiLayerRequest"/> + <type name="XrNegotiateLoaderInfo"/> + <type name="XrNegotiateRuntimeRequest"/> + </require> + </feature> + + <!-- SECTION: OpenXR 1.1 interface definitions --> + + <feature api="openxr" name="XR_VERSION_1_1" number="1.1"> + <require comment="API version"> + <type name="XR_API_VERSION_1_1"/> + </require> + + <require comment="Promoted from XR_KHR_maintenance1"> + + <!-- new structs --> + <type name="XrColor3f"/> + <type name="XrExtent3Df"/> + <type name="XrSpheref"/> + <type name="XrBoxf"/> + <type name="XrFrustumf"/> + + <!-- error codes --> + <enum name="XR_ERROR_EXTENSION_DEPENDENCY_NOT_ENABLED" extends="XrResult" extnumber="711" offset="1" dir="-" comment="One or more of the extensions being enabled has dependency on extensions that are not enabled."/> + <enum name="XR_ERROR_PERMISSION_INSUFFICIENT" extends="XrResult" extnumber="711" offset="0" dir="-" comment="Insufficient permissions. This error is included for use by vendor extensions. The precise definition of `XR_ERROR_PERMISSION_INSUFFICIENT` and actions possible by the developer or user to resolve it can vary by platform, extension or function. The developer should refer to the documentation of the function that returned the error code and extension it was defined."/> + </require> + + <!-- XrUuid --> + <require comment="Promoted from XR_EXT_uuid"> + <enum name="XR_UUID_SIZE"/> + <type name="XrUuid"/> + </require> + + <!-- xrLocateSpaces --> + <require comment="Promoted from XR_KHR_locate_spaces"> + <enum name="XR_TYPE_SPACES_LOCATE_INFO" extends="XrStructureType" extnumber="472" offset="0"/> + <enum name="XR_TYPE_SPACE_LOCATIONS" extends="XrStructureType" extnumber="472" offset="1"/> + <enum name="XR_TYPE_SPACE_VELOCITIES" extends="XrStructureType" extnumber="472" offset="2"/> + + <type name="XrSpacesLocateInfo"/> + <type name="XrSpaceLocationData"/> + <type name="XrSpaceLocations"/> + <type name="XrSpaceVelocityData"/> + <type name="XrSpaceVelocities"/> + + <command name="xrLocateSpaces"/> + </require> + + <!-- XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR --> + <require comment="Promoted from XR_EXT_local_floor"> + <enum name="XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR" extends="XrReferenceSpaceType" extnumber="427" offset="0"/> + </require> + + <!-- grip_surface - promoted version of XR_EXT_palm_pose --> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)"> + <extend interaction_profile_path="/interaction_profiles/khr/simple_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/google/daydream_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/htc/vive_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/microsoft/motion_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/oculus/go_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/oculus/touch_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/valve/index_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/htc/vive_cosmos_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/htc/vive_focus3_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/samsung/odyssey_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/hp/mixed_reality_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/ml/ml2_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_neo3_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico4_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_g3_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_MSFT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/microsoft/hand_interaction"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_HUAWEI_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/huawei/controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_HTC_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/htc/hand_interaction"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_HTCX_vive_tracker_interaction"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_tracker_htcx"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_OPPO_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/oppo/mr_controller_oppo"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_YVR_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/yvr/touch_controller_yvr"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_FB_touch_controller_pro"> + <extend interaction_profile_path="/interaction_profiles/facebook/touch_controller_pro"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_META_touch_controller_plus"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_plus"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_VARJO_xr4_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/varjo/xr-4_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/ext/hand_interaction_ext"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_LOGITECH_mx_ink_stylus_interaction"> + <extend interaction_profile_path="/interaction_profiles/logitech/mx_ink_stylus_logitech"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + <!-- Promote XR_VARJO_quad_views --> + <require comment="Promoted from XR_VARJO_quad_views"> + <enum name="XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO_WITH_FOVEATED_INSET" extends="XrViewConfigurationType" extnumber="38" offset="0"/> + </require> + + + <!-- Promote XR_ML_ml2_controller_interaction --> + <require comment="Promote /interaction_profiles/ml/ml2_controller interaction profile"> + <interaction_profile name="/interaction_profiles/ml/ml2_controller"/> + + <extend interaction_profile_path="/interaction_profiles/ml/ml2_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/ml/ml2_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/ml/ml2_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/ml/ml2_controller"> + <component subpath="/input/trackpad/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_center" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + + <!-- Promote XR_BD_controller_interaction --> + <require comment="Promote XR_BD_controller_interaction"> + <interaction_profile name="/interaction_profiles/bytedance/pico_neo3_controller"/> + <interaction_profile name="/interaction_profiles/bytedance/pico4_controller"/> + <interaction_profile name="/interaction_profiles/bytedance/pico_g3_controller"/> + + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_neo3_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico4_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_g3_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_neo3_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico4_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_g3_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_neo3_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico4_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_g3_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_neo3_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico4_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_g3_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + <!-- Promote XR_HTC_vive_cosmos_controller_interaction --> + <require comment="Promote /interaction_profiles/htc/vive_cosmos_controller interaction profile"> + <interaction_profile name="/interaction_profiles/htc/vive_cosmos_controller"/> + + <extend interaction_profile_path="/interaction_profiles/htc/vive_cosmos_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_cosmos_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_cosmos_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_cosmos_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + <!-- Promote XR_HTC_vive_focus3_controller_interaction --> + <require comment="Promote /interaction_profiles/htc/vive_focus3_controller interaction profile"> + <interaction_profile name="/interaction_profiles/htc/vive_focus3_controller"/> + + <extend interaction_profile_path="/interaction_profiles/htc/vive_focus3_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_focus3_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_focus3_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_focus3_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + <!-- Promote XR_EXT_samsung_odyssey_controller --> + <require comment="Promote /interaction_profiles/samsung/odyssey_controller interaction profile"> + <interaction_profile name="/interaction_profiles/samsung/odyssey_controller"/> + + <extend interaction_profile_path="/interaction_profiles/samsung/odyssey_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/samsung/odyssey_controller"> + <component subpath="/input/trackpad/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_center" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/samsung/odyssey_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/samsung/odyssey_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + <!-- Promote XR_EXT_hp_mixed_reality_controller --> + <require comment="Promote /interaction_profiles/hp/mixed_reality_controller interaction profile"> + <interaction_profile name="/interaction_profiles/hp/mixed_reality_controller"/> + + <extend interaction_profile_path="/interaction_profiles/hp/mixed_reality_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/hp/mixed_reality_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/hp/mixed_reality_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/hp/mixed_reality_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + <!-- Promote XR_FB_touch_controller_pro --> + <require comment="Promote (and rename) /interaction_profiles/facebook/touch_controller_pro interaction profile"> + <interaction_profile name="/interaction_profiles/meta/touch_pro_controller"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_pro_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_pro_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_pro_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + <!-- Promote XR_META_touch_controller_plus --> + <require comment="Promote (and rename) /interaction_profiles/meta/touch_controller_plus interaction profile"> + <interaction_profile name="/interaction_profiles/meta/touch_plus_controller"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_plus_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_plus_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_plus_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + <!-- Promote Meta legacy touch controller profiles --> + <require comment="Promote legacy touch_controller profiles"> + <interaction_profile name="/interaction_profiles/meta/touch_controller_rift_cv1"/> + <interaction_profile name="/interaction_profiles/meta/touch_controller_quest_1_rift_s"/> + <interaction_profile name="/interaction_profiles/meta/touch_controller_quest_2"/> + </require> + + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_rift_cv1"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_quest_1_rift_s"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_quest_2"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_rift_cv1"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_quest_1_rift_s"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_quest_2"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_rift_cv1"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_quest_1_rift_s"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_quest_2"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + + <!-- Promote XR_FB_touch_controller_proximity --> + <require comment="Promote XR_FB_touch_controller_proximity interaction profile paths"> + <extend interaction_profile_path="/interaction_profiles/oculus/touch_controller"> + <component subpath="/input/trigger/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumb_resting_surfaces/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + + </feature> + + <!-- SECTION: OpenXR extension interface definitions --> + <extensions> + <!-- Android Thread Settings extension --> + <extension name="XR_KHR_android_thread_settings" number="4" type="instance" supported="openxr" protect="XR_USE_PLATFORM_ANDROID" ratified="openxr"> + <require> + <enum value="6" name="XR_KHR_android_thread_settings_SPEC_VERSION"/> + <enum value=""XR_KHR_android_thread_settings"" name="XR_KHR_ANDROID_THREAD_SETTINGS_EXTENSION_NAME"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_ANDROID_THREAD_SETTINGS_ID_INVALID_KHR" comment="xrSetAndroidApplicationThreadKHR failed as thread id is invalid."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_ANDROID_THREAD_SETTINGS_FAILURE_KHR" comment="xrSetAndroidApplicationThreadKHR failed setting the thread attributes/priority."/> + <type name="XrAndroidThreadTypeKHR"/> + <command name="xrSetAndroidApplicationThreadKHR"/> + </require> + </extension> + + <!-- Android Surface Swapchain extension --> + <extension name="XR_KHR_android_surface_swapchain" number="5" type="instance" supported="openxr" protect="XR_USE_PLATFORM_ANDROID" ratified="openxr"> + <require> + <enum value="4" name="XR_KHR_android_surface_swapchain_SPEC_VERSION"/> + <enum value=""XR_KHR_android_surface_swapchain"" name="XR_KHR_ANDROID_SURFACE_SWAPCHAIN_EXTENSION_NAME"/> + <command name="xrCreateSwapchainAndroidSurfaceKHR"/> + </require> + </extension> + + <!-- Non-core composition cube layer --> + <extension name="XR_KHR_composition_layer_cube" number="7" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="8" name="XR_KHR_composition_layer_cube_SPEC_VERSION"/> + <enum value=""XR_KHR_composition_layer_cube"" name="XR_KHR_COMPOSITION_LAYER_CUBE_EXTENSION_NAME"/> + <type name="XrCompositionLayerCubeKHR"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_CUBE_KHR"/> + </require> + </extension> + + <!-- Android Create Instance extension --> + <extension name="XR_KHR_android_create_instance" number="9" type="instance" supported="openxr" protect="XR_USE_PLATFORM_ANDROID" ratified="openxr"> + <require> + <enum value="3" name="XR_KHR_android_create_instance_SPEC_VERSION"/> + <enum value=""XR_KHR_android_create_instance"" name="XR_KHR_ANDROID_CREATE_INSTANCE_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_INSTANCE_CREATE_INFO_ANDROID_KHR"/> + <type name="XrInstanceCreateInfoAndroidKHR"/> + </require> + </extension> + + <!-- Runtime support for additional per-layer depth info --> + <extension name="XR_KHR_composition_layer_depth" number="11" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="6" name="XR_KHR_composition_layer_depth_SPEC_VERSION"/> + <enum value=""XR_KHR_composition_layer_depth"" name="XR_KHR_COMPOSITION_LAYER_DEPTH_EXTENSION_NAME"/> + <type name="XrCompositionLayerDepthInfoKHR"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_DEPTH_INFO_KHR"/> + </require> + </extension> + + <!-- Reserved for headless "graphics binding" extension --> + <extension name="XR_KHR_headless" number="14" type="instance" supported="disabled"> + <require> + <enum value="4" name="XR_KHR_headless_SPEC_VERSION"/> + <enum value=""XR_KHR_headless"" name="XR_KHR_HEADLESS_EXTENSION_NAME"/> + </require> + </extension> + + + <!-- Vulkan image format list extension --> + <extension name="XR_KHR_vulkan_swapchain_format_list" number="15" type="instance" depends="XR_VERSION_1_0+XR_KHR_vulkan_enable,XR_VERSION_1_0+XR_KHR_vulkan_enable2" supported="openxr" protect="XR_USE_GRAPHICS_API_VULKAN" ratified="openxr"> + <require> + <enum value="5" name="XR_KHR_vulkan_swapchain_format_list_SPEC_VERSION"/> + <enum value=""XR_KHR_vulkan_swapchain_format_list"" name="XR_KHR_VULKAN_SWAPCHAIN_FORMAT_LIST_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_VULKAN_SWAPCHAIN_FORMAT_LIST_CREATE_INFO_KHR"/> + <type name="XrVulkanSwapchainFormatListCreateInfoKHR"/> + </require> + </extension> + + <!-- Performance Settings extension --> + <extension name="XR_EXT_performance_settings" number="16" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="4" name="XR_EXT_performance_settings_SPEC_VERSION"/> + <enum value=""XR_EXT_performance_settings"" name="XR_EXT_PERFORMANCE_SETTINGS_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_PERF_SETTINGS_EXT"/> + <type name="XrPerfSettingsDomainEXT"/> + <type name="XrPerfSettingsSubDomainEXT"/> + <type name="XrPerfSettingsLevelEXT"/> + <type name="XrPerfSettingsNotificationLevelEXT"/> + <type name="XrEventDataPerfSettingsEXT"/> + <command name="xrPerfSettingsSetPerformanceLevelEXT"/> + </require> + </extension> + + <!-- Thermal Query extension --> + <extension name="XR_EXT_thermal_query" number="17" type="instance" supported="openxr"> + <require> + <enum value="2" name="XR_EXT_thermal_query_SPEC_VERSION"/> + <enum value=""XR_EXT_thermal_query"" name="XR_EXT_THERMAL_QUERY_EXTENSION_NAME"/> + <type name="XrPerfSettingsDomainEXT"/> + <type name="XrPerfSettingsNotificationLevelEXT"/> + <command name="xrThermalGetTemperatureTrendEXT"/> + </require> + </extension> + + <!-- Non-core composition cylinder layer --> + <extension name="XR_KHR_composition_layer_cylinder" number="18" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="4" name="XR_KHR_composition_layer_cylinder_SPEC_VERSION"/> + <enum value=""XR_KHR_composition_layer_cylinder"" name="XR_KHR_COMPOSITION_LAYER_CYLINDER_EXTENSION_NAME"/> + <type name="XrCompositionLayerCylinderKHR"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_CYLINDER_KHR"/> + </require> + </extension> + + <!-- Non-core composition equilateral rect layer --> + <extension name="XR_KHR_composition_layer_equirect" number="19" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="3" name="XR_KHR_composition_layer_equirect_SPEC_VERSION"/> + <enum value=""XR_KHR_composition_layer_equirect"" name="XR_KHR_COMPOSITION_LAYER_EQUIRECT_EXTENSION_NAME"/> + <type name="XrCompositionLayerEquirectKHR"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_EQUIRECT_KHR"/> + </require> + </extension> + + <!-- Debug Utilities extension --> + <extension name="XR_EXT_debug_utils" number="20" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="5" name="XR_EXT_debug_utils_SPEC_VERSION"/> + <enum value=""XR_EXT_debug_utils"" name="XR_EXT_DEBUG_UTILS_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_DEBUG_UTILS_LABEL_EXT"/> + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT" comment="XrDebugUtilsMessengerEXT"/> + <type name="PFN_xrDebugUtilsMessengerCallbackEXT"/> + <type name="XrDebugUtilsObjectNameInfoEXT"/> + <type name="XrDebugUtilsLabelEXT"/> + <type name="XrDebugUtilsMessengerEXT"/> + <type name="XrDebugUtilsMessengerCallbackDataEXT"/> + <type name="XrDebugUtilsMessengerCreateInfoEXT"/> + <type name="XrDebugUtilsMessageTypeFlagsEXT"/> + <type name="XrDebugUtilsMessageTypeFlagBitsEXT"/> + <type name="XrDebugUtilsMessageSeverityFlagsEXT"/> + <type name="XrDebugUtilsMessageSeverityFlagBitsEXT"/> + <command name="xrSetDebugUtilsObjectNameEXT"/> + <command name="xrCreateDebugUtilsMessengerEXT"/> + <command name="xrDestroyDebugUtilsMessengerEXT"/> + <command name="xrSubmitDebugUtilsMessageEXT"/> + <command name="xrSessionBeginDebugUtilsLabelRegionEXT"/> + <command name="xrSessionEndDebugUtilsLabelRegionEXT"/> + <command name="xrSessionInsertDebugUtilsLabelEXT"/> + </require> + </extension> + + <!-- Reserved space for Variable rate rendering extension --> + <extension name="XR_KHR_variable_rate_rendering" number="21" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_KHR_variable_rate_rendering_SPEC_VERSION"/> + <enum value=""XR_KHR_variable_rate_rendering"" name="XR_KHR_VARIABLE_RATE_RENDERING_EXTENSION_NAME"/> + </require> + </extension> + + <!-- Reserved space for Overlays extension --> + <extension name="XR_KHR_overlays" number="22" type="instance" supported="disabled"> + <require> + <enum value="0" name="XR_KHR_overlays_SPEC_VERSION"/> + <enum value=""XR_KHR_overlays"" name="XR_KHR_OVERLAYS_EXTENSION_NAME"/> + </require> + </extension> + + <!-- OpenGL graphics binding extension --> + <extension name="XR_KHR_opengl_enable" number="24" type="instance" protect="XR_USE_GRAPHICS_API_OPENGL" supported="openxr" ratified="openxr"> + <require> + <enum value="12" name="XR_KHR_opengl_enable_SPEC_VERSION"/> + <enum value=""XR_KHR_opengl_enable"" name="XR_KHR_OPENGL_ENABLE_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_GRAPHICS_BINDING_OPENGL_WIN32_KHR"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_GRAPHICS_BINDING_OPENGL_XLIB_KHR"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_GRAPHICS_BINDING_OPENGL_XCB_KHR"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_GRAPHICS_BINDING_OPENGL_WAYLAND_KHR"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_KHR"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_KHR"/> + <type name="XrGraphicsBindingOpenGLWin32KHR"/> + <type name="XrGraphicsBindingOpenGLXlibKHR"/> + <type name="XrGraphicsBindingOpenGLXcbKHR"/> + <type name="XrGraphicsBindingOpenGLWaylandKHR"/> + <type name="XrSwapchainImageOpenGLKHR"/> + <type name="XrGraphicsRequirementsOpenGLKHR"/> + <command name="xrGetOpenGLGraphicsRequirementsKHR"/> + </require> + </extension> + + <!-- OpenGL ES graphics binding extension --> + <extension name="XR_KHR_opengl_es_enable" number="25" type="instance" protect="XR_USE_GRAPHICS_API_OPENGL_ES" supported="openxr" ratified="openxr"> + <require> + <enum value="10" name="XR_KHR_opengl_es_enable_SPEC_VERSION"/> + <enum value=""XR_KHR_opengl_es_enable"" name="XR_KHR_OPENGL_ES_ENABLE_EXTENSION_NAME"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_ES_KHR"/> + <type name="XrGraphicsBindingOpenGLESAndroidKHR"/> + <type name="XrSwapchainImageOpenGLESKHR"/> + <type name="XrGraphicsRequirementsOpenGLESKHR"/> + <command name="xrGetOpenGLESGraphicsRequirementsKHR"/> + </require> + </extension> + + <!-- Vulkan graphics binding extension --> + <extension name="XR_KHR_vulkan_enable" number="26" type="instance" protect="XR_USE_GRAPHICS_API_VULKAN" supported="openxr" ratified="openxr"> + <require> + <enum value="10" name="XR_KHR_vulkan_enable_SPEC_VERSION"/> + <enum value=""XR_KHR_vulkan_enable"" name="XR_KHR_VULKAN_ENABLE_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR"/> + <type name="XrGraphicsBindingVulkanKHR"/> + <type name="XrSwapchainImageVulkanKHR"/> + <type name="XrGraphicsRequirementsVulkanKHR"/> + <command name="xrGetVulkanInstanceExtensionsKHR"/> + <command name="xrGetVulkanDeviceExtensionsKHR"/> + <command name="xrGetVulkanGraphicsDeviceKHR"/> + <command name="xrGetVulkanGraphicsRequirementsKHR"/> + </require> + </extension> + + <!-- Value used by obsolete D3D10 graphics binding extension --> + <extension name="XR_KHR_D3D10_enable_obsolete" number="27" type="instance" supported="disabled"> + <require> + <enum value="4" name="XR_KHR_D3D10_enable_obsolete_SPEC_VERSION"/> + <enum value=""XR_KHR_D3D10_enable_obsolete"" name="XR_KHR_D3D10_ENABLE_OBSOLETE_EXTENSION_NAME"/> + </require> + </extension> + + <!-- D3D11 graphics binding extension --> + <extension name="XR_KHR_D3D11_enable" number="28" type="instance" protect="XR_USE_GRAPHICS_API_D3D11" supported="openxr" ratified="openxr"> + <require> + <enum value="11" name="XR_KHR_D3D11_enable_SPEC_VERSION"/> + <enum value=""XR_KHR_D3D11_enable"" name="XR_KHR_D3D11_ENABLE_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_GRAPHICS_BINDING_D3D11_KHR"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_IMAGE_D3D11_KHR"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_GRAPHICS_REQUIREMENTS_D3D11_KHR"/> + <type name="XrGraphicsBindingD3D11KHR"/> + <type name="XrSwapchainImageD3D11KHR"/> + <type name="XrGraphicsRequirementsD3D11KHR"/> + <command name="xrGetD3D11GraphicsRequirementsKHR"/> + </require> + </extension> + + <!-- D3D12 graphics binding extension --> + <extension name="XR_KHR_D3D12_enable" number="29" type="instance" protect="XR_USE_GRAPHICS_API_D3D12" supported="openxr" ratified="openxr"> + <require> + <enum value="11" name="XR_KHR_D3D12_enable_SPEC_VERSION"/> + <enum value=""XR_KHR_D3D12_enable"" name="XR_KHR_D3D12_ENABLE_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_GRAPHICS_BINDING_D3D12_KHR"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_IMAGE_D3D12_KHR"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_GRAPHICS_REQUIREMENTS_D3D12_KHR"/> + <type name="XrGraphicsBindingD3D12KHR"/> + <type name="XrSwapchainImageD3D12KHR"/> + <type name="XrGraphicsRequirementsD3D12KHR"/> + <command name="xrGetD3D12GraphicsRequirementsKHR"/> + </require> + </extension> + + <!-- Metal graphics binding extension --> + <extension name="XR_KHR_metal_enable" number="30" type="instance" protect="XR_USE_GRAPHICS_API_METAL" supported="openxr" ratified="openxr"> + <require> + <enum value="3" name="XR_KHR_metal_enable_SPEC_VERSION"/> + <enum value=""XR_KHR_metal_enable"" name="XR_KHR_METAL_ENABLE_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_GRAPHICS_BINDING_METAL_KHR"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_IMAGE_METAL_KHR"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_GRAPHICS_REQUIREMENTS_METAL_KHR"/> + <type name="XrGraphicsBindingMetalKHR"/> + <type name="XrSwapchainImageMetalKHR"/> + <type name="XrGraphicsRequirementsMetalKHR"/> + <command name="xrGetMetalGraphicsRequirementsKHR"/> + </require> + </extension> + + <!-- Eye gaze interaction extension --> + <extension name="XR_EXT_eye_gaze_interaction" number="31" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="2" name="XR_EXT_eye_gaze_interaction_SPEC_VERSION"/> + <enum value=""XR_EXT_eye_gaze_interaction"" name="XR_EXT_EYE_GAZE_INTERACTION_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_EYE_GAZE_INTERACTION_PROPERTIES_EXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_EYE_GAZE_SAMPLE_TIME_EXT"/> + <type name="XrSystemEyeGazeInteractionPropertiesEXT"/> + <type name="XrEyeGazeSampleTimeEXT"/> + + <interaction_profile name="/interaction_profiles/ext/eye_gaze_interaction"/> + </require> + </extension> + + <!-- Visibility mask extension --> + <extension name="XR_KHR_visibility_mask" number="32" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="2" name="XR_KHR_visibility_mask_SPEC_VERSION"/> + <enum value=""XR_KHR_visibility_mask"" name="XR_KHR_VISIBILITY_MASK_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_VISIBILITY_MASK_KHR"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR"/> + <type name="XrVisibilityMaskTypeKHR"/> + <type name="XrVisibilityMaskKHR"/> + <type name="XrEventDataVisibilityMaskChangedKHR"/> + <command name="xrGetVisibilityMaskKHR"/> + </require> + </extension> + + <!-- Reserved space for EXT permissions support --> + <extension name="XR_EXT_permissions_support" number="33" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_permissions_support_SPEC_VERSION"/> + <enum value=""XR_EXT_permissions_support"" name="XR_EXT_PERMISSIONS_SUPPORT_EXTENSION_NAME"/> + </require> + </extension> + + <!-- Overlay preview extension --> + <extension name="XR_EXTX_overlay" number="34" type="instance" provisional="true" supported="openxr"> + <require> + <enum value="5" name="XR_EXTX_overlay_SPEC_VERSION"/> + <enum value=""XR_EXTX_overlay"" name="XR_EXTX_OVERLAY_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SESSION_CREATE_INFO_OVERLAY_EXTX"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_MAIN_SESSION_VISIBILITY_CHANGED_EXTX"/> + <type name="XrSessionCreateInfoOverlayEXTX"/> + <type name="XrEventDataMainSessionVisibilityChangedEXTX"/> + <type name="XrOverlayMainSessionFlagsEXTX"/> + <type name="XrOverlayMainSessionFlagBitsEXTX"/> + <type name="XrOverlaySessionCreateFlagsEXTX"/> + <type name="XrOverlaySessionCreateFlagBitsEXTX"/> + </require> + </extension> + + + <!-- per-layer color scale and bias --> + <extension name="XR_KHR_composition_layer_color_scale_bias" number="35" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="5" name="XR_KHR_composition_layer_color_scale_bias_SPEC_VERSION"/> + <enum value=""XR_KHR_composition_layer_color_scale_bias"" name="XR_KHR_COMPOSITION_LAYER_COLOR_SCALE_BIAS_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_COLOR_SCALE_BIAS_KHR"/> + <type name="XrCompositionLayerColorScaleBiasKHR"/> + </require> + </extension> + + <extension name="XR_KHR_win32_convert_performance_counter_time" number="36" type="instance" supported="openxr" protect="XR_USE_PLATFORM_WIN32" ratified="openxr"> + <require> + <enum value="1" name="XR_KHR_win32_convert_performance_counter_time_SPEC_VERSION"/> + <enum value=""XR_KHR_win32_convert_performance_counter_time"" name="XR_KHR_WIN32_CONVERT_PERFORMANCE_COUNTER_TIME_EXTENSION_NAME"/> + <command name="xrConvertWin32PerformanceCounterToTimeKHR"/> + <command name="xrConvertTimeToWin32PerformanceCounterKHR"/> + </require> + </extension> + + <extension name="XR_KHR_convert_timespec_time" number="37" type="instance" supported="openxr" protect="XR_USE_TIMESPEC" ratified="openxr"> + <require> + <enum value="1" name="XR_KHR_convert_timespec_time_SPEC_VERSION"/> + <enum value=""XR_KHR_convert_timespec_time"" name="XR_KHR_CONVERT_TIMESPEC_TIME_EXTENSION_NAME"/> + <command name="xrConvertTimespecTimeToTimeKHR"/> + <command name="xrConvertTimeToTimespecTimeKHR"/> + </require> + </extension> + + <extension name="XR_VARJO_quad_views" number="38" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="2" name="XR_VARJO_quad_views_SPEC_VERSION"/> + <enum value=""XR_VARJO_quad_views"" name="XR_VARJO_QUAD_VIEWS_EXTENSION_NAME"/> + <enum extends="XrViewConfigurationType" name="XR_VIEW_CONFIGURATION_TYPE_PRIMARY_QUAD_VARJO" alias="XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO_WITH_FOVEATED_INSET"/> + </require> + </extension> + + <extension name="XR_MSFT_unbounded_reference_space" number="39" type="instance" supported="openxr" deprecatedby=""> + <require> + <enum value="1" name="XR_MSFT_unbounded_reference_space_SPEC_VERSION"/> + <enum value=""XR_MSFT_unbounded_reference_space"" name="XR_MSFT_UNBOUNDED_REFERENCE_SPACE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrReferenceSpaceType" name="XR_REFERENCE_SPACE_TYPE_UNBOUNDED_MSFT"/> + </require> + </extension> + + <extension name="XR_MSFT_spatial_anchor" number="40" type="instance" supported="openxr" obsoletedby="XR_EXT_spatial_anchor"> + <require> + <enum value="2" name="XR_MSFT_spatial_anchor_SPEC_VERSION"/> + <enum value=""XR_MSFT_spatial_anchor"" name="XR_MSFT_SPATIAL_ANCHOR_EXTENSION_NAME"/> + + <type name="XrSpatialAnchorMSFT"/> + <type name="XrSpatialAnchorCreateInfoMSFT"/> + <type name="XrSpatialAnchorSpaceCreateInfoMSFT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_MSFT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_SPACE_CREATE_INFO_MSFT"/> + <command name="xrCreateSpatialAnchorMSFT"/> + <command name="xrCreateSpatialAnchorSpaceMSFT"/> + <command name="xrDestroySpatialAnchorMSFT"/> + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SPATIAL_ANCHOR_MSFT" comment="XrSpatialAnchorMSFT"/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_CREATE_SPATIAL_ANCHOR_FAILED_MSFT" comment="Spatial anchor could not be created at that location."/> + </require> + </extension> + + <extension name="XR_FB_composition_layer_image_layout" number="41" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_composition_layer_image_layout_SPEC_VERSION"/> + <enum value=""XR_FB_composition_layer_image_layout"" name="XR_FB_COMPOSITION_LAYER_IMAGE_LAYOUT_EXTENSION_NAME"/> + <type name="XrCompositionLayerImageLayoutFB"/> + <type name="XrCompositionLayerImageLayoutFlagsFB"/> + <type name="XrCompositionLayerImageLayoutFlagBitsFB"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_IMAGE_LAYOUT_FB"/> + </require> + </extension> + + <extension name="XR_FB_composition_layer_alpha_blend" number="42" type="instance" supported="openxr"> + <require> + <enum value="3" name="XR_FB_composition_layer_alpha_blend_SPEC_VERSION"/> + <enum value=""XR_FB_composition_layer_alpha_blend"" name="XR_FB_COMPOSITION_LAYER_ALPHA_BLEND_EXTENSION_NAME"/> + <type name="XrBlendFactorFB"/> + <type name="XrCompositionLayerAlphaBlendFB"/> + <type name="XrCompositionLayerSecureContentFlagsFB"/> + <type name="XrCompositionLayerSecureContentFlagBitsFB"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_ALPHA_BLEND_FB"/> + </require> + </extension> + + <extension name="XR_MND_headless" number="43" type="instance" supported="openxr"> + <require> + <enum value="3" name="XR_MND_headless_SPEC_VERSION"/> + <enum value=""XR_MND_headless"" name="XR_MND_HEADLESS_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_OCULUS_extension_44" number="44" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_OCULUS_extension_44_SPEC_VERSION"/> + <enum value=""XR_OCULUS_extension_44"" name="XR_OCULUS_EXTENSION_44_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_OCULUS_android_session_state_enable" number="45" type="instance" supported="openxr" deprecatedby=""> + <require> + <enum value="1" name="XR_OCULUS_android_session_state_enable_SPEC_VERSION"/> + <enum value=""XR_OCULUS_android_session_state_enable"" name="XR_OCULUS_ANDROID_SESSION_STATE_ENABLE_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_46" number="46" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_46_SPEC_VERSION"/> + <enum value=""XR_MND_extension_46"" name="XR_MND_EXTENSION_46_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_view_configuration_depth_range" number="47" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_view_configuration_depth_range_SPEC_VERSION"/> + <enum value=""XR_EXT_view_configuration_depth_range"" name="XR_EXT_VIEW_CONFIGURATION_DEPTH_RANGE_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_VIEW_CONFIGURATION_DEPTH_RANGE_EXT"/> + <type name="XrViewConfigurationDepthRangeEXT"/> + </require> + </extension> + + <extension name="XR_EXT_conformance_automation" number="48" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="3" name="XR_EXT_conformance_automation_SPEC_VERSION"/> + <enum value=""XR_EXT_conformance_automation"" name="XR_EXT_CONFORMANCE_AUTOMATION_EXTENSION_NAME"/> + <command name="xrSetInputDeviceActiveEXT"/> + <command name="xrSetInputDeviceStateBoolEXT"/> + <command name="xrSetInputDeviceStateFloatEXT"/> + <command name="xrSetInputDeviceStateVector2fEXT"/> + <command name="xrSetInputDeviceLocationEXT"/> + </require> + </extension> + + <extension name="XR_MNDX_egl_enable" number="49" type="instance" provisional="true" protect="XR_USE_PLATFORM_EGL" supported="openxr"> + <require> + <enum value="2" name="XR_MNDX_egl_enable_SPEC_VERSION"/> + <enum value=""XR_MNDX_egl_enable"" name="XR_MNDX_EGL_ENABLE_EXTENSION_NAME"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_GRAPHICS_BINDING_EGL_MNDX"/> + <type name="PFN_xrEglGetProcAddressMNDX"/> + <type name="XrGraphicsBindingEGLMNDX"/> + </require> + </extension> + + <extension name="XR_MSFT_spatial_graph_bridge" number="50" type="instance" supported="openxr" deprecatedby=""> + <require> + <enum value="2" name="XR_MSFT_spatial_graph_bridge_SPEC_VERSION"/> + <enum value=""XR_MSFT_spatial_graph_bridge"" name="XR_MSFT_SPATIAL_GRAPH_BRIDGE_EXTENSION_NAME"/> + <type name="XrSpatialGraphNodeBindingMSFT"/> + <type name="XrSpatialGraphNodeTypeMSFT"/> + <type name="XrSpatialGraphNodeSpaceCreateInfoMSFT"/> + <type name="XrSpatialGraphStaticNodeBindingCreateInfoMSFT"/> + <type name="XrSpatialGraphNodeBindingPropertiesGetInfoMSFT"/> + <type name="XrSpatialGraphNodeBindingPropertiesMSFT"/> + <command name="xrCreateSpatialGraphNodeSpaceMSFT"/> + <command name="xrTryCreateSpatialGraphStaticNodeBindingMSFT"/> + <command name="xrDestroySpatialGraphNodeBindingMSFT"/> + <command name="xrGetSpatialGraphNodeBindingPropertiesMSFT"/> + <enum value="16" name="XR_GUID_SIZE_MSFT"/> + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SPATIAL_GRAPH_NODE_BINDING_MSFT" comment="XrSpatialGraphNodeBindingMSFT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_GRAPH_NODE_SPACE_CREATE_INFO_MSFT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_GRAPH_STATIC_NODE_BINDING_CREATE_INFO_MSFT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_GET_INFO_MSFT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_MSFT"/> + </require> + </extension> + + <extension name="XR_MSFT_hand_interaction" number="51" type="instance" supported="openxr" promotedto="XR_EXT_hand_interaction"> + <require> + <enum value="1" name="XR_MSFT_hand_interaction_SPEC_VERSION"/> + <enum value=""XR_MSFT_hand_interaction"" name="XR_MSFT_HAND_INTERACTION_EXTENSION_NAME"/> + + <interaction_profile name="/interaction_profiles/microsoft/hand_interaction"/> + </require> + + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/microsoft/hand_interaction"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/microsoft/hand_interaction"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_EXT_hand_tracking" number="52" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="4" name="XR_EXT_hand_tracking_SPEC_VERSION"/> + <enum value=""XR_EXT_hand_tracking"" name="XR_EXT_HAND_TRACKING_EXTENSION_NAME"/> + + <command name="xrCreateHandTrackerEXT"/> + <command name="xrDestroyHandTrackerEXT"/> + <command name="xrLocateHandJointsEXT"/> + + <type name="XrHandEXT"/> + <type name="XrHandJointEXT"/> + <type name="XrHandJointSetEXT"/> + + <type name="XrHandTrackerEXT"/> + <type name="XrSystemHandTrackingPropertiesEXT"/> + <type name="XrHandTrackerCreateInfoEXT"/> + <type name="XrHandJointsLocateInfoEXT"/> + <type name="XrHandJointLocationEXT"/> + <type name="XrHandJointVelocityEXT"/> + <type name="XrHandJointLocationsEXT"/> + <type name="XrHandJointVelocitiesEXT"/> + <type name="XR_HAND_JOINT_COUNT_EXT"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_HAND_TRACKER_EXT" comment="XrHandTrackerEXT"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_HAND_TRACKING_PROPERTIES_EXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_HAND_TRACKER_CREATE_INFO_EXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_HAND_JOINTS_LOCATE_INFO_EXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_HAND_JOINT_LOCATIONS_EXT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_HAND_JOINT_VELOCITIES_EXT"/> + </require> + </extension> + + <extension name="XR_MSFT_hand_tracking_mesh" number="53" depends="XR_VERSION_1_0+XR_EXT_hand_tracking" type="instance" supported="openxr" deprecatedby=""> + <require> + <enum value="4" name="XR_MSFT_hand_tracking_mesh_SPEC_VERSION"/> + <enum value=""XR_MSFT_hand_tracking_mesh"" name="XR_MSFT_HAND_TRACKING_MESH_EXTENSION_NAME"/> + + <command name="xrCreateHandMeshSpaceMSFT"/> + <command name="xrUpdateHandMeshMSFT"/> + + <type name="XrSystemHandTrackingMeshPropertiesMSFT"/> + <type name="XrHandMeshSpaceCreateInfoMSFT"/> + <type name="XrHandMeshUpdateInfoMSFT"/> + <type name="XrHandMeshMSFT"/> + <type name="XrHandMeshIndexBufferMSFT"/> + <type name="XrHandMeshVertexBufferMSFT"/> + <type name="XrHandMeshVertexMSFT"/> + <type name="XrHandPoseTypeMSFT"/> + <type name="XrHandPoseTypeInfoMSFT"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_HAND_TRACKING_MESH_PROPERTIES_MSFT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_HAND_MESH_SPACE_CREATE_INFO_MSFT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_HAND_MESH_UPDATE_INFO_MSFT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_HAND_MESH_MSFT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_HAND_POSE_TYPE_INFO_MSFT"/> + </require> + </extension> + + <extension name="XR_MSFT_secondary_view_configuration" number="54" type="instance" supported="openxr" deprecatedby=""> + <require> + <enum value="1" name="XR_MSFT_secondary_view_configuration_SPEC_VERSION"/> + <enum value=""XR_MSFT_secondary_view_configuration"" name="XR_MSFT_SECONDARY_VIEW_CONFIGURATION_EXTENSION_NAME"/> + <type name="XrSecondaryViewConfigurationSessionBeginInfoMSFT"/> + <type name="XrSecondaryViewConfigurationStateMSFT"/> + <type name="XrSecondaryViewConfigurationFrameStateMSFT"/> + <type name="XrSecondaryViewConfigurationFrameEndInfoMSFT"/> + <type name="XrSecondaryViewConfigurationLayerInfoMSFT"/> + <type name="XrSecondaryViewConfigurationSwapchainCreateInfoMSFT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_SESSION_BEGIN_INFO_MSFT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_STATE_MSFT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_FRAME_STATE_MSFT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_FRAME_END_INFO_MSFT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_LAYER_INFO_MSFT"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_SWAPCHAIN_CREATE_INFO_MSFT"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SECONDARY_VIEW_CONFIGURATION_TYPE_NOT_ENABLED_MSFT" comment="The secondary view configuration was not enabled when creating the session."/> + </require> + </extension> + + <extension name="XR_MSFT_first_person_observer" number="55" type="instance" depends="XR_VERSION_1_0+XR_MSFT_secondary_view_configuration" supported="openxr" deprecatedby=""> + <require> + <enum value="1" name="XR_MSFT_first_person_observer_SPEC_VERSION"/> + <enum value=""XR_MSFT_first_person_observer"" name="XR_MSFT_FIRST_PERSON_OBSERVER_EXTENSION_NAME"/> + <enum offset="0" extends="XrViewConfigurationType" name="XR_VIEW_CONFIGURATION_TYPE_SECONDARY_MONO_FIRST_PERSON_OBSERVER_MSFT"/> + </require> + </extension> + + <extension name="XR_MSFT_controller_model" number="56" type="instance" supported="openxr" obsoletedby="XR_EXT_interaction_render_model"> + <require> + <enum value="2" name="XR_MSFT_controller_model_SPEC_VERSION"/> + <enum value=""XR_MSFT_controller_model"" name="XR_MSFT_CONTROLLER_MODEL_EXTENSION_NAME"/> + + <type name="XrControllerModelKeyStateMSFT"/> + <type name="XrControllerModelNodePropertiesMSFT"/> + <type name="XrControllerModelPropertiesMSFT"/> + <type name="XrControllerModelNodeStateMSFT"/> + <type name="XrControllerModelStateMSFT"/> + <type name="XrControllerModelKeyMSFT"/> + <type name="XR_NULL_CONTROLLER_MODEL_KEY_MSFT"/> + + <command name="xrGetControllerModelKeyMSFT"/> + <command name="xrLoadControllerModelMSFT"/> + <command name="xrGetControllerModelPropertiesMSFT"/> + <command name="xrGetControllerModelStateMSFT"/> + + <enum value="64" name="XR_MAX_CONTROLLER_MODEL_NODE_NAME_SIZE_MSFT"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_CONTROLLER_MODEL_KEY_STATE_MSFT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_CONTROLLER_MODEL_NODE_PROPERTIES_MSFT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_CONTROLLER_MODEL_PROPERTIES_MSFT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_CONTROLLER_MODEL_NODE_STATE_MSFT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_CONTROLLER_MODEL_STATE_MSFT"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_CONTROLLER_MODEL_KEY_INVALID_MSFT" comment="The controller model key is invalid."/> + + </require> + </extension> + + <extension name="XR_MSFT_perception_anchor_interop" number="57" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_MSFT_spatial_anchor" protect="XR_USE_PLATFORM_WIN32" deprecatedby=""> + <require> + <enum value="1" name="XR_MSFT_perception_anchor_interop_SPEC_VERSION"/> + <enum value=""XR_MSFT_perception_anchor_interop"" name="XR_MSFT_PERCEPTION_ANCHOR_INTEROP_EXTENSION_NAME"/> + + <command name="xrCreateSpatialAnchorFromPerceptionAnchorMSFT"/> + <command name="xrTryGetPerceptionAnchorFromSpatialAnchorMSFT"/> + + </require> + </extension> + + <extension name="XR_EXT_win32_appcontainer_compatible" number="58" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_EXT_win32_appcontainer_compatible_SPEC_VERSION"/> + <enum value=""XR_EXT_win32_appcontainer_compatible"" name="XR_EXT_WIN32_APPCONTAINER_COMPATIBLE_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_59" number="59" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_59_SPEC_VERSION"/> + <enum value=""XR_ML_extension_59"" name="XR_ML_extension_59_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EPIC_view_configuration_fov" number="60" type="instance" supported="openxr"> + <require> + <enum value="2" name="XR_EPIC_view_configuration_fov_SPEC_VERSION"/> + <enum value=""XR_EPIC_view_configuration_fov"" name="XR_EPIC_VIEW_CONFIGURATION_FOV_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_VIEW_CONFIGURATION_VIEW_FOV_EPIC"/> + <type name="XrViewConfigurationViewFovEPIC"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_63" number="63" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_63_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_63"" name="XR_MSFT_extension_63_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_holographic_window_attachment" number="64" type="instance" supported="openxr" protect="XR_USE_PLATFORM_WIN32" deprecatedby=""> + <require> + <enum value="1" name="XR_MSFT_holographic_window_attachment_SPEC_VERSION"/> + <enum value=""XR_MSFT_holographic_window_attachment"" name="XR_MSFT_HOLOGRAPHIC_WINDOW_ATTACHMENT_EXTENSION_NAME"/> + <type name="XrHolographicWindowAttachmentMSFT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_HOLOGRAPHIC_WINDOW_ATTACHMENT_MSFT"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_65" number="65" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_65_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_65"" name="XR_MSFT_extension_65_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_66" number="66" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_66_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_66"" name="XR_MSFT_extension_66_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_composition_layer_reprojection" number="67" type="instance" supported="openxr" deprecatedby=""> + <require> + <enum value="1" name="XR_MSFT_composition_layer_reprojection_SPEC_VERSION"/> + <enum value=""XR_MSFT_composition_layer_reprojection"" name="XR_MSFT_COMPOSITION_LAYER_REPROJECTION_EXTENSION_NAME"/> + + <type name="XrReprojectionModeMSFT"/> + <type name="XrCompositionLayerReprojectionInfoMSFT"/> + <type name="XrCompositionLayerReprojectionPlaneOverrideMSFT"/> + + <command name="xrEnumerateReprojectionModesMSFT"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_REPROJECTION_INFO_MSFT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_REPROJECTION_PLANE_OVERRIDE_MSFT"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_REPROJECTION_MODE_UNSUPPORTED_MSFT" comment="The reprojection mode is not supported."/> + + </require> + </extension> + + <extension name="XR_LUNARG_extension_68" number="68" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LUNARG_extension_68_SPEC_VERSION"/> + <enum value=""XR_LUNARG_extension_68"" name="XR_LUNARG_extension_68_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LUNARG_extension_69" number="69" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LUNARG_extension_69_SPEC_VERSION"/> + <enum value=""XR_LUNARG_extension_69"" name="XR_LUNARG_extension_69_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HUAWEI_controller_interaction" number="70" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_HUAWEI_controller_interaction_SPEC_VERSION"/> + <enum value=""XR_HUAWEI_controller_interaction"" name="XR_HUAWEI_CONTROLLER_INTERACTION_EXTENSION_NAME"/> + + <interaction_profile name="/interaction_profiles/huawei/controller"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/huawei/controller"> + <component subpath="/input/trackpad/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_center" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/huawei/controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/huawei/controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_FB_android_surface_swapchain_create" number="71" type="instance" supported="openxr" protect="XR_USE_PLATFORM_ANDROID" depends="XR_VERSION_1_0+XR_KHR_android_surface_swapchain"> + <require> + <enum value="1" name="XR_FB_android_surface_swapchain_create_SPEC_VERSION"/> + <enum value=""XR_FB_android_surface_swapchain_create"" name="XR_FB_ANDROID_SURFACE_SWAPCHAIN_CREATE_EXTENSION_NAME"/> + + <type name="XrAndroidSurfaceSwapchainCreateInfoFB"/> + <type name="XrAndroidSurfaceSwapchainFlagsFB"/> + <type name="XrAndroidSurfaceSwapchainFlagBitsFB"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_ANDROID_SURFACE_SWAPCHAIN_CREATE_INFO_FB"/> + </require> + </extension> + + <extension name="XR_FB_swapchain_update_state" number="72" type="instance" supported="openxr"> + <require> + <enum value="3" name="XR_FB_swapchain_update_state_SPEC_VERSION"/> + <enum value=""XR_FB_swapchain_update_state"" name="XR_FB_SWAPCHAIN_UPDATE_STATE_EXTENSION_NAME"/> + + <type name="XrSwapchainStateBaseHeaderFB"/> + <command name="xrUpdateSwapchainFB"/> + <command name="xrGetSwapchainStateFB"/> + </require> + </extension> + + <extension name="XR_FB_composition_layer_secure_content" number="73" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_composition_layer_secure_content_SPEC_VERSION"/> + <enum value=""XR_FB_composition_layer_secure_content"" name="XR_FB_COMPOSITION_LAYER_SECURE_CONTENT_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_SECURE_CONTENT_FB"/> + <type name="XrCompositionLayerSecureContentFB"/> + </require> + </extension> + + <extension name="XR_FB_extension_74" number="74" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_74_SPEC_VERSION"/> + <enum value=""XR_FB_extension_74"" name="XR_FB_extension_74_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_75" number="75" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_75_SPEC_VERSION"/> + <enum value=""XR_FB_extension_75"" name="XR_FB_extension_75_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_76" number="76" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_76_SPEC_VERSION"/> + <enum value=""XR_FB_extension_76"" name="XR_FB_extension_76_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_body_tracking" number="77" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_body_tracking_SPEC_VERSION"/> + <enum value=""XR_FB_body_tracking"" name="XR_FB_BODY_TRACKING_EXTENSION_NAME"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_BODY_TRACKER_FB" comment="XrBodyTrackerFB"/> + <type name="XrBodyTrackerFB"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_BODY_TRACKER_CREATE_INFO_FB"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_BODY_JOINTS_LOCATE_INFO_FB"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_FB"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_BODY_JOINT_LOCATIONS_FB"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_BODY_SKELETON_FB"/> + + <type name="XrBodyJointFB"/> + <type name="XrBodyJointSetFB"/> + <type name="XrBodyJointFB"/> + <type name="XrBodyJointLocationFB"/> + + <type name="XrSystemBodyTrackingPropertiesFB"/> + <type name="XrBodyTrackerCreateInfoFB"/> + <type name="XrBodySkeletonJointFB"/> + <type name="XrBodySkeletonFB"/> + <type name="XrBodyJointsLocateInfoFB"/> + <type name="XrBodyJointLocationsFB"/> + + <command name="xrCreateBodyTrackerFB"/> + <command name="xrDestroyBodyTrackerFB"/> + <command name="xrLocateBodyJointsFB"/> + <command name="xrGetBodySkeletonFB"/> + </require> + </extension> + + <extension name="XR_FB_extension_78" number="78" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_78_SPEC_VERSION"/> + <enum value=""XR_FB_extension_78"" name="XR_FB_extension_78_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_dpad_binding" number="79" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_KHR_binding_modification" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_dpad_binding_SPEC_VERSION"/> + <enum value=""XR_EXT_dpad_binding"" name="XR_EXT_DPAD_BINDING_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_INTERACTION_PROFILE_DPAD_BINDING_EXT"/> + <type name="XrInteractionProfileDpadBindingEXT"/> + + <!-- + Only core 1.0 interaction profiles get extended here. + Others get this pose added in a nested <require depends="XR_EXT_dpad_binding"> + inside the extension and/or feature that adds them. + --> + <extend interaction_profile_path="/interaction_profiles/google/daydream_controller"> + <component subpath="/input/trackpad/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_center" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/htc/vive_controller"> + <component subpath="/input/trackpad/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_center" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/oculus/go_controller"> + <component subpath="/input/trackpad/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_center" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/oculus/touch_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/microsoft/motion_controller"> + <component subpath="/input/trackpad/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_center" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/microsoft/xbox_controller"> + <component subpath="/input/thumbstick_left/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick_left/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick_left/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick_left/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick_right/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick_right/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick_right/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick_right/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/valve/index_controller"> + <component subpath="/input/trackpad/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_center" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_VALVE_analog_threshold" number="80" type="instance" supported="openxr"> + <require> + <enum value="2" name="XR_VALVE_analog_threshold_SPEC_VERSION"/> + <enum value=""XR_VALVE_analog_threshold"" name="XR_VALVE_ANALOG_THRESHOLD_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_INTERACTION_PROFILE_ANALOG_THRESHOLD_VALVE"/> + <type name="XrInteractionProfileAnalogThresholdVALVE"/> + </require> + </extension> + + <extension name="XR_EXT_hand_joints_motion_range" number="81" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_EXT_hand_tracking" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_hand_joints_motion_range_SPEC_VERSION"/> + <enum value=""XR_EXT_hand_joints_motion_range"" name="XR_EXT_HAND_JOINTS_MOTION_RANGE_EXTENSION_NAME"/> + + <type name="XrHandJointsMotionRangeEXT"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_HAND_JOINTS_MOTION_RANGE_INFO_EXT"/> + <type name="XrHandJointsMotionRangeInfoEXT"/> + </require> + </extension> + + <extension name="XR_VALVE_extension_82" number="82" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VALVE_extension_82_SPEC_VERSION"/> + <enum value=""XR_VALVE_extension_82"" name="XR_VALVE_extension_82_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VALVE_extension_83" number="83" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VALVE_extension_83_SPEC_VERSION"/> + <enum value=""XR_VALVE_extension_83"" name="XR_VALVE_extension_83_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VALVE_extension_84" number="84" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VALVE_extension_84_SPEC_VERSION"/> + <enum value=""XR_VALVE_extension_84"" name="XR_VALVE_extension_84_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VALVE_extension_85" number="85" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VALVE_extension_85_SPEC_VERSION"/> + <enum value=""XR_VALVE_extension_85"" name="XR_VALVE_extension_85_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VALVE_extension_86" number="86" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VALVE_extension_86_SPEC_VERSION"/> + <enum value=""XR_VALVE_extension_86"" name="XR_VALVE_extension_86_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VALVE_extension_87" number="87" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VALVE_extension_87_SPEC_VERSION"/> + <enum value=""XR_VALVE_extension_87"" name="XR_VALVE_extension_87_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VALVE_extension_88" number="88" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VALVE_extension_88_SPEC_VERSION"/> + <enum value=""XR_VALVE_extension_88"" name="XR_VALVE_extension_88_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_KHR_loader_init" number="89" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="2" name="XR_KHR_loader_init_SPEC_VERSION"/> + <enum value=""XR_KHR_loader_init"" name="XR_KHR_LOADER_INIT_EXTENSION_NAME"/> + <type name="XrLoaderInitInfoBaseHeaderKHR"/> + <command name="xrInitializeLoaderKHR"/> + </require> + </extension> + + <extension name="XR_KHR_loader_init_android" number="90" type="instance" supported="openxr" protect="XR_USE_PLATFORM_ANDROID" depends="XR_VERSION_1_0+XR_KHR_loader_init" ratified="openxr"> + <require> + <enum value="1" name="XR_KHR_loader_init_android_SPEC_VERSION"/> + <enum value=""XR_KHR_loader_init_android"" name="XR_KHR_LOADER_INIT_ANDROID_EXTENSION_NAME"/> + <type name="XrLoaderInitInfoAndroidKHR"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_LOADER_INIT_INFO_ANDROID_KHR"/> + </require> + </extension> + + <extension name="XR_KHR_vulkan_enable2" number="91" type="instance" protect="XR_USE_GRAPHICS_API_VULKAN" supported="openxr" ratified="openxr"> + <require> + <enum value="4" name="XR_KHR_vulkan_enable2_SPEC_VERSION"/> + <enum value=""XR_KHR_vulkan_enable2"" name="XR_KHR_VULKAN_ENABLE2_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_VULKAN_INSTANCE_CREATE_INFO_KHR"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_VULKAN_DEVICE_CREATE_INFO_KHR"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_VULKAN_GRAPHICS_DEVICE_GET_INFO_KHR"/> + <enum extends="XrStructureType" name="XR_TYPE_GRAPHICS_BINDING_VULKAN2_KHR" alias="XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR"/> + <enum extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_IMAGE_VULKAN2_KHR" alias="XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR"/> + <enum extends="XrStructureType" name="XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN2_KHR" alias="XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR"/> + <type name="XrVulkanInstanceCreateInfoKHR"/> + <type name="XrVulkanDeviceCreateInfoKHR"/> + <type name="XrGraphicsBindingVulkan2KHR"/> + <type name="XrVulkanInstanceCreateFlagsKHR"/> + <type name="XrVulkanInstanceCreateFlagBitsKHR"/> + <type name="XrVulkanDeviceCreateFlagsKHR"/> + <type name="XrVulkanDeviceCreateFlagBitsKHR"/> + <type name="XrVulkanGraphicsDeviceGetInfoKHR"/> + <type name="XrSwapchainImageVulkan2KHR"/> + <type name="XrGraphicsRequirementsVulkan2KHR"/> + <command name="xrCreateVulkanInstanceKHR"/> + <command name="xrCreateVulkanDeviceKHR"/> + <command name="xrGetVulkanGraphicsDevice2KHR"/> + <command name="xrGetVulkanGraphicsRequirements2KHR"/> + </require> + </extension> + + <extension name="XR_KHR_composition_layer_equirect2" number="92" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="1" name="XR_KHR_composition_layer_equirect2_SPEC_VERSION"/> + <enum value=""XR_KHR_composition_layer_equirect2"" name="XR_KHR_COMPOSITION_LAYER_EQUIRECT2_EXTENSION_NAME"/> + <type name="XrCompositionLayerEquirect2KHR"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_EQUIRECT2_KHR"/> + </require> + </extension> + + <extension name="XR_EXT_extension_93" number="93" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_93_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_93"" name="XR_EXT_extension_93_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_system_extensions" number="94" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_system_extensions_SPEC_VERSION"/> + <enum value=""XR_EXT_system_extensions"" name="XR_EXT_system_extensions_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_samsung_odyssey_controller" number="95" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="1" name="XR_EXT_samsung_odyssey_controller_SPEC_VERSION"/> + <enum value=""XR_EXT_samsung_odyssey_controller"" name="XR_EXT_SAMSUNG_ODYSSEY_CONTROLLER_EXTENSION_NAME"/> + + <interaction_profile name="/interaction_profiles/samsung/odyssey_controller"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/samsung/odyssey_controller"> + <component subpath="/input/trackpad/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_center" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/samsung/odyssey_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/samsung/odyssey_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_EXT_hp_mixed_reality_controller" number="96" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="1" name="XR_EXT_hp_mixed_reality_controller_SPEC_VERSION"/> + <enum value=""XR_EXT_hp_mixed_reality_controller"" name="XR_EXT_HP_MIXED_REALITY_CONTROLLER_EXTENSION_NAME"/> + + <interaction_profile name="/interaction_profiles/hp/mixed_reality_controller"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/hp/mixed_reality_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/hp/mixed_reality_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/hp/mixed_reality_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_MND_swapchain_usage_input_attachment_bit" number="97" type="instance" supported="openxr" deprecatedby="XR_KHR_swapchain_usage_input_attachment_bit"> + <require> + <enum value="2" name="XR_MND_swapchain_usage_input_attachment_bit_SPEC_VERSION"/> + <enum value=""XR_MND_swapchain_usage_input_attachment_bit"" name="XR_MND_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_EXTENSION_NAME"/> + <!-- NOTE: This was added before the working group established a process, and has been normalized by promotion to KHR. Future vendor extensions MUST NOT extend core bitmasks. --> + <enum bitpos="7" extends="XrSwapchainUsageFlagBits" name="XR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_MND" comment="Specifies that the image may: be used as a input attachment."/> + </require> + </extension> + + <extension name="XR_MSFT_scene_understanding" number="98" type="instance" supported="openxr" obsoletedby="XR_EXT_spatial_entity"> + <require> + <enum value="2" name="XR_MSFT_scene_understanding_SPEC_VERSION"/> + <enum value=""XR_MSFT_scene_understanding"" name="XR_MSFT_SCENE_UNDERSTANDING_EXTENSION_NAME"/> + <type name="XrUuidMSFT"/> + <type name="XrSceneMSFT"/> + <type name="XrSceneObserverMSFT"/> + <type name="XrSceneObserverCreateInfoMSFT"/> + <type name="XrSceneCreateInfoMSFT"/> + <type name="XrNewSceneComputeInfoMSFT"/> + <type name="XrVisualMeshComputeLodInfoMSFT"/> + <type name="XrSceneSphereBoundMSFT"/> + <type name="XrSceneOrientedBoxBoundMSFT"/> + <type name="XrSceneFrustumBoundMSFT"/> + <type name="XrSceneBoundsMSFT"/> + <type name="XrSceneComponentMSFT"/> + <type name="XrSceneComponentsMSFT"/> + <type name="XrSceneComponentsGetInfoMSFT"/> + <type name="XrSceneComponentLocationMSFT"/> + <type name="XrSceneComponentLocationsMSFT"/> + <type name="XrSceneComponentsLocateInfoMSFT"/> + <type name="XrSceneObjectMSFT"/> + <type name="XrSceneObjectsMSFT"/> + <type name="XrSceneComponentParentFilterInfoMSFT"/> + <type name="XrSceneObjectTypesFilterInfoMSFT"/> + <type name="XrScenePlaneMSFT"/> + <type name="XrScenePlanesMSFT"/> + <type name="XrScenePlaneAlignmentFilterInfoMSFT"/> + <type name="XrSceneMeshMSFT"/> + <type name="XrSceneMeshesMSFT"/> + <type name="XrSceneMeshBuffersGetInfoMSFT"/> + <type name="XrSceneMeshBuffersMSFT"/> + <type name="XrSceneMeshVertexBufferMSFT"/> + <type name="XrSceneMeshIndicesUint32MSFT"/> + <type name="XrSceneMeshIndicesUint16MSFT"/> + <type name="XrSceneObjectTypeMSFT"/> + <type name="XrScenePlaneAlignmentTypeMSFT"/> + <type name="XrSceneComputeStateMSFT"/> + <type name="XrSceneComponentTypeMSFT"/> + <type name="XrSceneComputeFeatureMSFT"/> + <type name="XrSceneComputeConsistencyMSFT"/> + <type name="XrMeshComputeLodMSFT"/> + <command name="xrEnumerateSceneComputeFeaturesMSFT"/> + <command name="xrCreateSceneObserverMSFT"/> + <command name="xrDestroySceneObserverMSFT"/> + <command name="xrCreateSceneMSFT"/> + <command name="xrDestroySceneMSFT"/> + <command name="xrComputeNewSceneMSFT"/> + <command name="xrGetSceneComputeStateMSFT"/> + <command name="xrGetSceneComponentsMSFT"/> + <command name="xrLocateSceneComponentsMSFT"/> + <command name="xrGetSceneMeshBuffersMSFT"/> + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SCENE_OBSERVER_MSFT" comment="XrSceneObserverMSFT"/> + <enum offset="1" extends="XrObjectType" name="XR_OBJECT_TYPE_SCENE_MSFT" comment="XrSceneMSFT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SCENE_OBSERVER_CREATE_INFO_MSFT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SCENE_CREATE_INFO_MSFT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_NEW_SCENE_COMPUTE_INFO_MSFT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_VISUAL_MESH_COMPUTE_LOD_INFO_MSFT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SCENE_COMPONENTS_MSFT"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_SCENE_COMPONENTS_GET_INFO_MSFT"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_SCENE_COMPONENT_LOCATIONS_MSFT"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_SCENE_COMPONENTS_LOCATE_INFO_MSFT"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_SCENE_OBJECTS_MSFT"/> + <enum offset="9" extends="XrStructureType" name="XR_TYPE_SCENE_COMPONENT_PARENT_FILTER_INFO_MSFT"/> + <enum offset="10" extends="XrStructureType" name="XR_TYPE_SCENE_OBJECT_TYPES_FILTER_INFO_MSFT"/> + <enum offset="11" extends="XrStructureType" name="XR_TYPE_SCENE_PLANES_MSFT"/> + <enum offset="12" extends="XrStructureType" name="XR_TYPE_SCENE_PLANE_ALIGNMENT_FILTER_INFO_MSFT"/> + <enum offset="13" extends="XrStructureType" name="XR_TYPE_SCENE_MESHES_MSFT"/> + <enum offset="14" extends="XrStructureType" name="XR_TYPE_SCENE_MESH_BUFFERS_GET_INFO_MSFT"/> + <enum offset="15" extends="XrStructureType" name="XR_TYPE_SCENE_MESH_BUFFERS_MSFT"/> + <enum offset="16" extends="XrStructureType" name="XR_TYPE_SCENE_MESH_VERTEX_BUFFER_MSFT"/> + <enum offset="17" extends="XrStructureType" name="XR_TYPE_SCENE_MESH_INDICES_UINT32_MSFT"/> + <enum offset="18" extends="XrStructureType" name="XR_TYPE_SCENE_MESH_INDICES_UINT16_MSFT"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_COMPUTE_NEW_SCENE_NOT_COMPLETED_MSFT" comment="Compute new scene not completed."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SCENE_COMPONENT_ID_INVALID_MSFT" comment="Scene component id invalid."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_SCENE_COMPONENT_TYPE_MISMATCH_MSFT" comment="Scene component type mismatch."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_SCENE_MESH_BUFFER_ID_INVALID_MSFT" comment="Scene mesh buffer id invalid."/> + <enum offset="4" dir="-" extends="XrResult" name="XR_ERROR_SCENE_COMPUTE_FEATURE_INCOMPATIBLE_MSFT" comment="Scene compute feature incompatible."/> + <enum offset="5" dir="-" extends="XrResult" name="XR_ERROR_SCENE_COMPUTE_CONSISTENCY_MISMATCH_MSFT" comment="Scene compute consistency mismatch."/> + </require> + </extension> + + <extension name="XR_MSFT_scene_understanding_serialization" number="99" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_MSFT_scene_understanding" deprecatedby=""> + <require> + <enum value="2" name="XR_MSFT_scene_understanding_serialization_SPEC_VERSION"/> + <enum value=""XR_MSFT_scene_understanding_serialization"" name="XR_MSFT_SCENE_UNDERSTANDING_SERIALIZATION_EXTENSION_NAME"/> + <type name="XrSerializedSceneFragmentDataGetInfoMSFT"/> + <type name="XrDeserializeSceneFragmentMSFT"/> + <type name="XrSceneDeserializeInfoMSFT"/> + <command name="xrDeserializeSceneMSFT"/> + <command name="xrGetSerializedSceneFragmentDataMSFT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SERIALIZED_SCENE_FRAGMENT_DATA_GET_INFO_MSFT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SCENE_DESERIALIZE_INFO_MSFT"/> + <enum offset="0" extends="XrSceneComputeFeatureMSFT" name="XR_SCENE_COMPUTE_FEATURE_SERIALIZE_SCENE_MSFT"/> + <enum offset="0" extends="XrSceneComponentTypeMSFT" name="XR_SCENE_COMPONENT_TYPE_SERIALIZED_SCENE_FRAGMENT_MSFT"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_100" number="100" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_100_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_100"" name="XR_MSFT_extension_100_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_101" number="101" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_101_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_101"" name="XR_MSFT_extension_101_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_display_refresh_rate" number="102" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_display_refresh_rate_SPEC_VERSION"/> + <enum value=""XR_FB_display_refresh_rate"" name="XR_FB_DISPLAY_REFRESH_RATE_EXTENSION_NAME"/> + + <type name="XrEventDataDisplayRefreshRateChangedFB"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB"/> + + <command name="xrEnumerateDisplayRefreshRatesFB"/> + <command name="xrGetDisplayRefreshRateFB"/> + <command name="xrRequestDisplayRefreshRateFB"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_DISPLAY_REFRESH_RATE_UNSUPPORTED_FB" comment="The display refresh rate is not supported by the platform."/> + </require> + </extension> + + <extension name="XR_HTC_vive_cosmos_controller_interaction" number="103" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="1" name="XR_HTC_vive_cosmos_controller_interaction_SPEC_VERSION"/> + <enum value=""XR_HTC_vive_cosmos_controller_interaction"" name="XR_HTC_VIVE_COSMOS_CONTROLLER_INTERACTION_EXTENSION_NAME"/> + + <interaction_profile name="/interaction_profiles/htc/vive_cosmos_controller"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_cosmos_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_cosmos_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_cosmos_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_HTCX_vive_tracker_interaction" number="104" type="instance" provisional="true" supported="openxr"> + <require> + <enum value="3" name="XR_HTCX_vive_tracker_interaction_SPEC_VERSION"/> + <enum value=""XR_HTCX_vive_tracker_interaction"" name="XR_HTCX_VIVE_TRACKER_INTERACTION_EXTENSION_NAME"/> + <type name="XrViveTrackerPathsHTCX"/> + <type name="XrEventDataViveTrackerConnectedHTCX"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_VIVE_TRACKER_PATHS_HTCX"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_VIVE_TRACKER_CONNECTED_HTCX"/> + <command name="xrEnumerateViveTrackerPathsHTCX"/> + <interaction_profile name="/interaction_profiles/htc/vive_tracker_htcx"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_tracker_htcx"> + <component subpath="/input/trackpad/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_center" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_HTC_facial_tracking" number="105" type="instance" supported="openxr"> + <require> + <enum value="3" name="XR_HTC_facial_tracking_SPEC_VERSION"/> + <enum value=""XR_HTC_facial_tracking"" name="XR_HTC_FACIAL_TRACKING_EXTENSION_NAME"/> + + <type name="XrFacialTrackerHTC"/> + <type name="XrSystemFacialTrackingPropertiesHTC"/> + <type name="XrFacialExpressionsHTC"/> + <type name="XrEyeExpressionHTC"/> + <type name="XrLipExpressionHTC"/> + <type name="XrFacialTrackerCreateInfoHTC"/> + <type name="XrFacialTrackingTypeHTC"/> + <type name="XR_FACIAL_EXPRESSION_EYE_COUNT_HTC"/> + <type name="XR_FACIAL_EXPRESSION_LIP_COUNT_HTC"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_FACIAL_TRACKER_HTC" comment="XrFacialTrackerHTC"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_FACIAL_TRACKING_PROPERTIES_HTC"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_FACIAL_TRACKER_CREATE_INFO_HTC"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_FACIAL_EXPRESSIONS_HTC"/> + + <command name="xrCreateFacialTrackerHTC"/> + <command name="xrDestroyFacialTrackerHTC"/> + <command name="xrGetFacialExpressionsHTC"/> + + <enum extends="XrLipExpressionHTC" name="XR_LIP_EXPRESSION_MOUTH_SMILE_RIGHT_HTC" alias="XR_LIP_EXPRESSION_MOUTH_RAISER_RIGHT_HTC" comment="Backward-compatibility alias for deprecated name."/> + <enum extends="XrLipExpressionHTC" name="XR_LIP_EXPRESSION_MOUTH_SMILE_LEFT_HTC" alias="XR_LIP_EXPRESSION_MOUTH_RAISER_LEFT_HTC" comment="Backward-compatibility alias for deprecated name."/> + <enum extends="XrLipExpressionHTC" name="XR_LIP_EXPRESSION_MOUTH_SAD_RIGHT_HTC" alias="XR_LIP_EXPRESSION_MOUTH_STRETCHER_RIGHT_HTC" comment="Backward-compatibility alias for deprecated name."/> + <enum extends="XrLipExpressionHTC" name="XR_LIP_EXPRESSION_MOUTH_SAD_LEFT_HTC" alias="XR_LIP_EXPRESSION_MOUTH_STRETCHER_LEFT_HTC" comment="Backward-compatibility alias for deprecated name."/> + </require> + </extension> + + <extension name="XR_HTC_vive_focus3_controller_interaction" number="106" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="2" name="XR_HTC_vive_focus3_controller_interaction_SPEC_VERSION"/> + <enum value=""XR_HTC_vive_focus3_controller_interaction"" name="XR_HTC_VIVE_FOCUS3_CONTROLLER_INTERACTION_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/htc/vive_focus3_controller"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_focus3_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_focus3_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_focus3_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_HTC_hand_interaction" number="107" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_HTC_hand_interaction_SPEC_VERSION"/> + <enum value=""XR_HTC_hand_interaction"" name="XR_HTC_HAND_INTERACTION_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/htc/hand_interaction"/> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/htc/hand_interaction"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/htc/hand_interaction"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_HTC_vive_wrist_tracker_interaction" number="108" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_HTC_vive_wrist_tracker_interaction_SPEC_VERSION"/> + <enum value=""XR_HTC_vive_wrist_tracker_interaction"" name="XR_HTC_VIVE_WRIST_TRACKER_INTERACTION_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/htc/vive_wrist_tracker"/> + </require> + </extension> + + <extension name="XR_FB_color_space" number="109" type="instance" supported="openxr"> + <require> + <enum value="3" name="XR_FB_color_space_SPEC_VERSION"/> + <enum value=""XR_FB_color_space"" name="XR_FB_COLOR_SPACE_EXTENSION_NAME"/> + + <type name="XrColorSpaceFB"/> + <type name="XrSystemColorSpacePropertiesFB"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_COLOR_SPACE_PROPERTIES_FB"/> + + <command name="xrEnumerateColorSpacesFB"/> + <command name="xrSetColorSpaceFB"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_COLOR_SPACE_UNSUPPORTED_FB" comment="The color space is not supported by the runtime."/> + </require> + </extension> + + <extension name="XR_FB_extension_110" number="110" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_110_SPEC_VERSION"/> + <enum value=""XR_FB_extension_110"" name="XR_FB_extension_110_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_hand_tracking_mesh" number="111" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_EXT_hand_tracking"> + <require> + <enum value="3" name="XR_FB_hand_tracking_mesh_SPEC_VERSION"/> + <enum value=""XR_FB_hand_tracking_mesh"" name="XR_FB_HAND_TRACKING_MESH_EXTENSION_NAME"/> + + <type name="XrVector4sFB"/> + <type name="XrHandTrackingMeshFB"/> + <type name="XrHandTrackingScaleFB"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_HAND_TRACKING_MESH_FB"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_HAND_TRACKING_SCALE_FB"/> + + <command name="xrGetHandMeshFB"/> + </require> + </extension> + + <extension name="XR_FB_hand_tracking_aim" number="112" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_EXT_hand_tracking"> + <require> + <enum value="2" name="XR_FB_hand_tracking_aim_SPEC_VERSION"/> + <enum value=""XR_FB_hand_tracking_aim"" name="XR_FB_HAND_TRACKING_AIM_EXTENSION_NAME"/> + + <type name="XrHandTrackingAimStateFB"/> + <type name="XrHandTrackingAimFlagsFB"/> + <type name="XrHandTrackingAimFlagBitsFB"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_HAND_TRACKING_AIM_STATE_FB"/> + </require> + </extension> + + <extension name="XR_FB_hand_tracking_capsules" number="113" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_EXT_hand_tracking"> + <require> + <enum value="3" name="XR_FB_hand_tracking_capsules_SPEC_VERSION"/> + <enum value=""XR_FB_hand_tracking_capsules"" name="XR_FB_HAND_TRACKING_CAPSULES_EXTENSION_NAME"/> + + <type name="XrHandCapsuleFB"/> + <type name="XrHandTrackingCapsulesStateFB"/> + + <enum value="2" name="XR_HAND_TRACKING_CAPSULE_POINT_COUNT_FB"/> + <enum value="19" name="XR_HAND_TRACKING_CAPSULE_COUNT_FB"/> + + <enum name="XR_FB_HAND_TRACKING_CAPSULE_POINT_COUNT" alias="XR_HAND_TRACKING_CAPSULE_POINT_COUNT_FB" comment="Backward-compatibility alias containing typo."/> + + <enum name="XR_FB_HAND_TRACKING_CAPSULE_COUNT" alias="XR_HAND_TRACKING_CAPSULE_COUNT_FB" comment="Backward-compatibility alias containing typo."/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_HAND_TRACKING_CAPSULES_STATE_FB"/> + </require> + </extension> + + <extension name="XR_FB_spatial_entity" number="114" type="instance" supported="openxr"> + <require> + <enum value="3" name="XR_FB_spatial_entity_SPEC_VERSION"/> + <enum value=""XR_FB_spatial_entity"" name="XR_FB_SPATIAL_ENTITY_EXTENSION_NAME"/> + + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPATIAL_ENTITY_PROPERTIES_FB"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_FB"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_SPACE_COMPONENT_STATUS_SET_INFO_FB"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPACE_COMPONENT_STATUS_FB"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPATIAL_ANCHOR_CREATE_COMPLETE_FB"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPACE_SET_STATUS_COMPLETE_FB"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SPACE_COMPONENT_NOT_SUPPORTED_FB" comment="The component type is not supported for this space."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB" comment="The required component is not enabled for this space."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_SPACE_COMPONENT_STATUS_PENDING_FB" comment="A request to set the component's status is currently pending."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_SPACE_COMPONENT_STATUS_ALREADY_SET_FB" comment="The component is already set to the requested value."/> + + <type name="XrAsyncRequestIdFB"/> + + <type name="XrSpaceComponentTypeFB"/> + + <type name="XrSystemSpatialEntityPropertiesFB"/> + <type name="XrSpatialAnchorCreateInfoFB"/> + <type name="XrSpaceComponentStatusSetInfoFB"/> + <type name="XrSpaceComponentStatusFB"/> + + <type name="XrEventDataSpatialAnchorCreateCompleteFB"/> + <type name="XrEventDataSpaceSetStatusCompleteFB"/> + + <command name="xrCreateSpatialAnchorFB"/> + <command name="xrGetSpaceUuidFB"/> + <command name="xrEnumerateSpaceSupportedComponentsFB"/> + <command name="xrSetSpaceComponentStatusFB"/> + <command name="xrGetSpaceComponentStatusFB"/> + </require> + </extension> + + <extension name="XR_FB_foveation" number="115" type="instance" depends="XR_VERSION_1_0+XR_FB_swapchain_update_state" supported="openxr"> + <require> + <enum value="1" name="XR_FB_foveation_SPEC_VERSION"/> + <enum value=""XR_FB_foveation"" name="XR_FB_FOVEATION_EXTENSION_NAME"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_FOVEATION_PROFILE_FB" comment="XrFoveationProfileFB"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_FOVEATION_PROFILE_CREATE_INFO_FB"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_CREATE_INFO_FOVEATION_FB"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_STATE_FOVEATION_FB"/> + + <type name="XrFoveationProfileFB"/> + <type name="XrFoveationProfileCreateInfoFB"/> + <type name="XrSwapchainCreateInfoFoveationFB"/> + <type name="XrSwapchainCreateFoveationFlagsFB"/> + <type name="XrSwapchainCreateFoveationFlagBitsFB"/> + <type name="XrSwapchainStateFoveationFB"/> + <type name="XrSwapchainStateFoveationFlagsFB"/> + <type name="XrSwapchainStateFoveationFlagBitsFB"/> + + <command name="xrCreateFoveationProfileFB"/> + <command name="xrDestroyFoveationProfileFB"/> + </require> + </extension> + + <extension name="XR_FB_foveation_configuration" number="116" type="instance" depends="XR_VERSION_1_0+XR_FB_foveation" supported="openxr"> + <require> + <enum value="1" name="XR_FB_foveation_configuration_SPEC_VERSION"/> + <enum value=""XR_FB_foveation_configuration"" name="XR_FB_FOVEATION_CONFIGURATION_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_FOVEATION_LEVEL_PROFILE_CREATE_INFO_FB"/> + + <type name="XrFoveationLevelFB"/> + <type name="XrFoveationDynamicFB"/> + <type name="XrFoveationLevelProfileCreateInfoFB"/> + </require> + </extension> + + <extension name="XR_FB_keyboard_tracking" number="117" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_keyboard_tracking_SPEC_VERSION"/> + <enum value=""XR_FB_keyboard_tracking"" name="XR_FB_KEYBOARD_TRACKING_EXTENSION_NAME"/> + + <type name="XrSystemKeyboardTrackingPropertiesFB"/> + <type name="XrKeyboardTrackingDescriptionFB"/> + <type name="XrKeyboardSpaceCreateInfoFB"/> + <type name="XrKeyboardTrackingQueryFB"/> + <type name="XrKeyboardTrackingQueryFlagsFB"/> + <type name="XrKeyboardTrackingQueryFlagBitsFB"/> + <type name="XrKeyboardTrackingFlagsFB"/> + <type name="XrKeyboardTrackingFlagBitsFB"/> + + <enum value="128" name="XR_MAX_KEYBOARD_TRACKING_NAME_SIZE_FB"/> + + <enum offset="9" extends="XrStructureType" name="XR_TYPE_KEYBOARD_SPACE_CREATE_INFO_FB"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_KEYBOARD_TRACKING_QUERY_FB"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SYSTEM_KEYBOARD_TRACKING_PROPERTIES_FB"/> + + <command name="xrQuerySystemTrackedKeyboardFB"/> + <command name="xrCreateKeyboardSpaceFB"/> + </require> + </extension> + + <extension name="XR_FB_triangle_mesh" number="118" type="instance" supported="openxr"> + <require> + <enum value="2" name="XR_FB_triangle_mesh_SPEC_VERSION"/> + <enum value=""XR_FB_triangle_mesh"" name="XR_FB_TRIANGLE_MESH_EXTENSION_NAME"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_TRIANGLE_MESH_CREATE_INFO_FB"/> + + <type name="XrTriangleMeshFB"/> + <type name="XrTriangleMeshFlagsFB"/> + <type name="XrTriangleMeshFlagBitsFB"/> + <type name="XrTriangleMeshCreateInfoFB"/> + <type name="XrWindingOrderFB"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_TRIANGLE_MESH_FB" comment="XrTriangleMeshFB"/> + + <command name="xrCreateTriangleMeshFB"/> + <command name="xrDestroyTriangleMeshFB"/> + <command name="xrTriangleMeshGetVertexBufferFB"/> + <command name="xrTriangleMeshGetIndexBufferFB"/> + <command name="xrTriangleMeshBeginUpdateFB"/> + <command name="xrTriangleMeshEndUpdateFB"/> + <command name="xrTriangleMeshBeginVertexBufferUpdateFB"/> + <command name="xrTriangleMeshEndVertexBufferUpdateFB"/> + </require> + </extension> + + <extension name="XR_FB_passthrough" number="119" type="instance" supported="openxr"> + <require> + <enum value="5" name="XR_FB_passthrough_SPEC_VERSION"/> + <enum value=""XR_FB_passthrough"" name="XR_FB_PASSTHROUGH_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_PASSTHROUGH_PROPERTIES_FB"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_CREATE_INFO_FB"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_FB"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_FB"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_GEOMETRY_INSTANCE_CREATE_INFO_FB"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_GEOMETRY_INSTANCE_TRANSFORM_FB"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_SYSTEM_PASSTHROUGH_PROPERTIES2_FB"/> + <enum offset="20" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_STYLE_FB"/> + <enum offset="21" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_RGBA_FB"/> + <enum offset="22" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_MONO_FB"/> + <enum offset="23" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_BRIGHTNESS_CONTRAST_SATURATION_FB"/> + <enum offset="30" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_PASSTHROUGH_STATE_CHANGED_FB"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_UNEXPECTED_STATE_PASSTHROUGH_FB" comment="The object state is unexpected for the issued command."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_FEATURE_ALREADY_CREATED_PASSTHROUGH_FB" comment="Trying to create an MR feature when one was already created and only one instance is allowed."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_FEATURE_REQUIRED_PASSTHROUGH_FB" comment="Requested functionality requires a feature to be created first."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_NOT_PERMITTED_PASSTHROUGH_FB" comment="Requested functionality is not permitted - application is not allowed to perform the requested operation."/> + <enum offset="4" dir="-" extends="XrResult" name="XR_ERROR_INSUFFICIENT_RESOURCES_PASSTHROUGH_FB" comment="There were insufficient resources available to perform an operation."/> + <enum offset="50" dir="-" extends="XrResult" name="XR_ERROR_UNKNOWN_PASSTHROUGH_FB" comment="Unknown Passthrough error (no further details provided)."/> + + <enum value="256" name="XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_PASSTHROUGH_FB" comment="XrPassthroughFB"/> + <enum offset="2" extends="XrObjectType" name="XR_OBJECT_TYPE_PASSTHROUGH_LAYER_FB" comment="XrPassthroughLayerFB"/> + <enum offset="4" extends="XrObjectType" name="XR_OBJECT_TYPE_GEOMETRY_INSTANCE_FB" comment="XrGeometryInstanceFB"/> + + <type name="XrSystemPassthroughPropertiesFB"/> + <type name="XrSystemPassthroughProperties2FB"/> + <type name="XrPassthroughCreateInfoFB"/> + <type name="XrPassthroughLayerCreateInfoFB"/> + <type name="XrCompositionLayerPassthroughFB"/> + <type name="XrGeometryInstanceCreateInfoFB"/> + <type name="XrGeometryInstanceTransformFB"/> + <type name="XrPassthroughStyleFB"/> + <type name="XrPassthroughColorMapMonoToRgbaFB"/> + <type name="XrPassthroughColorMapMonoToMonoFB"/> + <type name="XrPassthroughBrightnessContrastSaturationFB"/> + <type name="XrEventDataPassthroughStateChangedFB"/> + + <type name="XrPassthroughFB"/> + <type name="XrPassthroughFlagsFB"/> + <type name="XrPassthroughFlagBitsFB"/> + <type name="XrPassthroughCapabilityFlagsFB"/> + <type name="XrPassthroughCapabilityFlagBitsFB"/> + <type name="XrGeometryInstanceFB"/> + <type name="XrPassthroughLayerFB"/> + <type name="XrPassthroughLayerPurposeFB"/> + <type name="XrPassthroughStateChangedFlagsFB"/> + <type name="XrPassthroughStateChangedFlagBitsFB"/> + + <command name="xrCreatePassthroughFB"/> + <command name="xrDestroyPassthroughFB"/> + <command name="xrPassthroughStartFB"/> + <command name="xrPassthroughPauseFB"/> + <command name="xrCreatePassthroughLayerFB"/> + <command name="xrDestroyPassthroughLayerFB"/> + <command name="xrPassthroughLayerPauseFB"/> + <command name="xrPassthroughLayerResumeFB"/> + <command name="xrPassthroughLayerSetStyleFB"/> + <command name="xrCreateGeometryInstanceFB"/> + <command name="xrDestroyGeometryInstanceFB"/> + <command name="xrGeometryInstanceSetTransformFB"/> + </require> + </extension> + + <extension name="XR_FB_render_model" number="120" type="instance" supported="openxr"> + <require> + <enum value="4" name="XR_FB_render_model_SPEC_VERSION"/> + <enum value=""XR_FB_render_model"" name="XR_FB_RENDER_MODEL_EXTENSION_NAME"/> + + <type name="XrRenderModelPathInfoFB"/> + <type name="XrRenderModelPropertiesFB"/> + <type name="XrRenderModelBufferFB"/> + <type name="XrRenderModelLoadInfoFB"/> + <type name="XrRenderModelKeyFB"/> + <type name="XrSystemRenderModelPropertiesFB"/> + <type name="XrRenderModelCapabilitiesRequestFB"/> + <type name="XrRenderModelFlagsFB"/> + <type name="XrRenderModelFlagBitsFB"/> + <type name="XR_NULL_RENDER_MODEL_KEY_FB"/> + + <command name="xrEnumerateRenderModelPathsFB"/> + <command name="xrGetRenderModelPropertiesFB"/> + <command name="xrLoadRenderModelFB"/> + + <enum value="64" name="XR_MAX_RENDER_MODEL_NAME_SIZE_FB"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_PATH_INFO_FB"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_PROPERTIES_FB"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_BUFFER_FB"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_LOAD_INFO_FB"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SYSTEM_RENDER_MODEL_PROPERTIES_FB"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_CAPABILITIES_REQUEST_FB"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_RENDER_MODEL_KEY_INVALID_FB" comment="The model key is invalid."/> + <enum offset="20" extends="XrResult" name="XR_RENDER_MODEL_UNAVAILABLE_FB" comment="The model is unavailable."/> + </require> + </extension> + + <extension name="XR_KHR_binding_modification" number="121" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="1" name="XR_KHR_binding_modification_SPEC_VERSION"/> + <enum value=""XR_KHR_binding_modification"" name="XR_KHR_BINDING_MODIFICATION_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_BINDING_MODIFICATIONS_KHR"/> + <type name="XrBindingModificationsKHR"/> + <type name="XrBindingModificationBaseHeaderKHR"/> + </require> + </extension> + + <extension name="XR_VARJO_foveated_rendering" number="122" type="instance" depends="XR_VERSION_1_0+XR_VARJO_quad_views" supported="openxr"> + <require> + <enum value="3" name="XR_VARJO_foveated_rendering_SPEC_VERSION"/> + <enum value=""XR_VARJO_foveated_rendering"" name="XR_VARJO_FOVEATED_RENDERING_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_VIEW_LOCATE_FOVEATED_RENDERING_VARJO"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_FOVEATED_VIEW_CONFIGURATION_VIEW_VARJO"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SYSTEM_FOVEATED_RENDERING_PROPERTIES_VARJO"/> + + <enum offset="0" extends="XrReferenceSpaceType" name="XR_REFERENCE_SPACE_TYPE_COMBINED_EYE_VARJO"/> + + <type name="XrViewLocateFoveatedRenderingVARJO"/> + <type name="XrFoveatedViewConfigurationViewVARJO"/> + <type name="XrSystemFoveatedRenderingPropertiesVARJO"/> + </require> + </extension> + + <extension name="XR_VARJO_composition_layer_depth_test" number="123" type="instance" depends="XR_VERSION_1_0+XR_KHR_composition_layer_depth" supported="openxr"> + <require> + <enum value="2" name="XR_VARJO_composition_layer_depth_test_SPEC_VERSION"/> + <enum value=""XR_VARJO_composition_layer_depth_test"" name="XR_VARJO_COMPOSITION_LAYER_DEPTH_TEST_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_DEPTH_TEST_VARJO"/> + <type name="XrCompositionLayerDepthTestVARJO"/> + </require> + </extension> + + <extension name="XR_VARJO_environment_depth_estimation" number="124" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_VARJO_environment_depth_estimation_SPEC_VERSION"/> + <enum value=""XR_VARJO_environment_depth_estimation"" name="XR_VARJO_ENVIRONMENT_DEPTH_ESTIMATION_EXTENSION_NAME"/> + <command name="xrSetEnvironmentDepthEstimationVARJO"/> + </require> + </extension> + + <extension name="XR_VARJO_marker_tracking" number="125" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_VARJO_marker_tracking_SPEC_VERSION"/> + <enum value=""XR_VARJO_marker_tracking"" name="XR_VARJO_MARKER_TRACKING_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_VARJO"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_MARKER_TRACKING_UPDATE_VARJO"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_MARKER_SPACE_CREATE_INFO_VARJO"/> + + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_MARKER_NOT_TRACKED_VARJO" comment="Marker tracking is disabled or the specified marker is not currently tracked."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_MARKER_ID_INVALID_VARJO" comment="The specified marker ID is not valid."/> + + <type name="XrSystemMarkerTrackingPropertiesVARJO"/> + <type name="XrEventDataMarkerTrackingUpdateVARJO"/> + <type name="XrMarkerSpaceCreateInfoVARJO"/> + + <command name="xrSetMarkerTrackingVARJO"/> + <command name="xrSetMarkerTrackingTimeoutVARJO"/> + <command name="xrSetMarkerTrackingPredictionVARJO"/> + <command name="xrGetMarkerSizeVARJO"/> + <command name="xrCreateMarkerSpaceVARJO"/> + </require> + </extension> + + <extension name="XR_VARJO_view_offset" number="126" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_VARJO_view_offset_SPEC_VERSION"/> + <enum value=""XR_VARJO_view_offset"" name="XR_VARJO_VIEW_OFFSET_EXTENSION_NAME"/> + <command name="xrSetViewOffsetVARJO"/> + </require> + </extension> + + <extension name="XR_VARJO_extension_127" number="127" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VARJO_extension_127_SPEC_VERSION"/> + <enum value=""XR_VARJO_extension_127"" name="XR_VARJO_extension_127_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VARJO_extension_128" number="128" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VARJO_extension_128_SPEC_VERSION"/> + <enum value=""XR_VARJO_extension_128"" name="XR_VARJO_extension_128_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VARJO_extension_129" number="129" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VARJO_extension_129_SPEC_VERSION"/> + <enum value=""XR_VARJO_extension_129"" name="XR_VARJO_extension_129_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VARJO_xr4_controller_interaction" number="130" type="instance" supported="openxr"> + <require> + <enum value="2" name="XR_VARJO_xr4_controller_interaction_SPEC_VERSION"/> + <enum value=""XR_VARJO_xr4_controller_interaction"" name="XR_VARJO_XR4_CONTROLLER_INTERACTION_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/varjo/xr-4_controller"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/varjo/xr-4_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/varjo/xr-4_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/varjo/xr-4_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_VARJO_extension_131" number="131" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VARJO_extension_131_SPEC_VERSION"/> + <enum value=""XR_VARJO_extension_131"" name="XR_VARJO_extension_131_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VARJO_extension_132" number="132" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VARJO_extension_132_SPEC_VERSION"/> + <enum value=""XR_VARJO_extension_132"" name="XR_VARJO_extension_132_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_133" number="133" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_133_SPEC_VERSION"/> + <enum value=""XR_ML_extension_133"" name="XR_ML_extension_133_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_134" number="134" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_134_SPEC_VERSION"/> + <enum value=""XR_ML_extension_134"" name="XR_ML_extension_134_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_ml2_controller_interaction" number="135" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="1" name="XR_ML_ml2_controller_interaction_SPEC_VERSION"/> + <enum value=""XR_ML_ml2_controller_interaction"" name="XR_ML_ML2_CONTROLLER_INTERACTION_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/ml/ml2_controller"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/ml/ml2_controller"> + <component subpath="/input/trackpad/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_center" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/ml/ml2_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/ml/ml2_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_ML_frame_end_info" number="136" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ML_frame_end_info_SPEC_VERSION"/> + <enum value=""XR_ML_frame_end_info"" name="XR_ML_FRAME_END_INFO_EXTENSION_NAME"/> + <type name="XrFrameEndInfoML"/> + <type name="XrFrameEndInfoFlagsML"/> + <type name="XrFrameEndInfoFlagBitsML"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_FRAME_END_INFO_ML"/> + </require> + </extension> + + <extension name="XR_ML_global_dimmer" number="137" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ML_global_dimmer_SPEC_VERSION"/> + <enum value=""XR_ML_global_dimmer"" name="XR_ML_GLOBAL_DIMMER_EXTENSION_NAME"/> + <type name="XrGlobalDimmerFrameEndInfoML"/> + <type name="XrGlobalDimmerFrameEndInfoFlagsML"/> + <type name="XrGlobalDimmerFrameEndInfoFlagBitsML"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_GLOBAL_DIMMER_FRAME_END_INFO_ML"/> + </require> + </extension> + + <extension name="XR_ML_compat" number="138" type="instance" supported="openxr" protect="XR_USE_PLATFORM_ML"> + <require> + <enum value="1" name="XR_ML_compat_SPEC_VERSION"/> + <enum value=""XR_ML_compat"" name="XR_ML_COMPAT_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COORDINATE_SPACE_CREATE_INFO_ML"/> + <command name="xrCreateSpaceFromCoordinateFrameUIDML"/> + <type name="XrCoordinateSpaceCreateInfoML"/> + </require> + </extension> + + <extension name="XR_ML_marker_understanding" number="139" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ML_marker_understanding_SPEC_VERSION"/> + <enum value=""XR_ML_marker_understanding"" name="XR_ML_MARKER_UNDERSTANDING_EXTENSION_NAME"/> + + <type name="XrMarkerML"/> + <type name="XrMarkerDetectorML"/> + + <type name="XrMarkerDetectorProfileML"/> + <type name="XrMarkerTypeML"/> + <type name="XrMarkerArucoDictML"/> + <type name="XrMarkerAprilTagDictML"/> + <type name="XrMarkerDetectorFpsML"/> + <type name="XrMarkerDetectorResolutionML"/> + <type name="XrMarkerDetectorCameraML"/> + <type name="XrMarkerDetectorCornerRefineMethodML"/> + <type name="XrMarkerDetectorFullAnalysisIntervalML"/> + <type name="XrMarkerDetectorStatusML"/> + + <type name="XrSystemMarkerUnderstandingPropertiesML"/> + <type name="XrMarkerDetectorCreateInfoML"/> + <type name="XrMarkerDetectorArucoInfoML"/> + <type name="XrMarkerDetectorSizeInfoML"/> + <type name="XrMarkerDetectorAprilTagInfoML"/> + <type name="XrMarkerDetectorCustomProfileInfoML"/> + <type name="XrMarkerDetectorSnapshotInfoML"/> + <type name="XrMarkerDetectorStateML"/> + <type name="XrMarkerSpaceCreateInfoML"/> + + <command name="xrCreateMarkerDetectorML"/> + <command name="xrDestroyMarkerDetectorML"/> + <command name="xrSnapshotMarkerDetectorML"/> + <command name="xrGetMarkerDetectorStateML"/> + <command name="xrGetMarkersML"/> + <command name="xrGetMarkerReprojectionErrorML"/> + <command name="xrGetMarkerLengthML"/> + <command name="xrGetMarkerNumberML"/> + <command name="xrGetMarkerStringML"/> + <command name="xrCreateMarkerSpaceML"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_MARKER_DETECTOR_ML" comment="XrMarkerDetectorML"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_MARKER_UNDERSTANDING_PROPERTIES_ML"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_MARKER_DETECTOR_CREATE_INFO_ML"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_MARKER_DETECTOR_ARUCO_INFO_ML"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_MARKER_DETECTOR_SIZE_INFO_ML"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_MARKER_DETECTOR_APRIL_TAG_INFO_ML"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_MARKER_DETECTOR_CUSTOM_PROFILE_INFO_ML"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_MARKER_DETECTOR_SNAPSHOT_INFO_ML"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_MARKER_DETECTOR_STATE_ML"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_MARKER_SPACE_CREATE_INFO_ML"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_MARKER_DETECTOR_PERMISSION_DENIED_ML" comment="The com.magicleap.permission.MARKER_TRACKING permission was denied."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_MARKER_DETECTOR_LOCATE_FAILED_ML" comment="The specified marker could not be located spatially."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_MARKER_DETECTOR_INVALID_DATA_QUERY_ML" comment="The marker queried does not contain data of the requested type."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_MARKER_DETECTOR_INVALID_CREATE_INFO_ML" comment="pname:createInfo contains mutually exclusive parameters, such as setting ename:XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_APRIL_TAG_ML with ename:XR_MARKER_TYPE_ARUCO_ML."/> + <enum offset="4" dir="-" extends="XrResult" name="XR_ERROR_MARKER_INVALID_ML" comment="The marker id passed to the function was invalid."/> + + </require> + </extension> + + <extension name="XR_ML_localization_map" number="140" type="instance" depends="XR_VERSION_1_0+XR_EXT_uuid" supported="openxr"> + <require> + <enum value="1" name="XR_ML_localization_map_SPEC_VERSION"/> + <enum value=""XR_ML_localization_map"" name="XR_ML_LOCALIZATION_MAP_EXTENSION_NAME"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_EXPORTED_LOCALIZATION_MAP_ML" comment="XrExportedLocalizationMapML"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_LOCALIZATION_MAP_ML"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_LOCALIZATION_CHANGED_ML"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_MAP_LOCALIZATION_REQUEST_INFO_ML"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_LOCALIZATION_MAP_IMPORT_INFO_ML"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_LOCALIZATION_ENABLE_EVENTS_INFO_ML"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_LOCALIZATION_MAP_INCOMPATIBLE_ML" comment="The localization map being imported is not compatible with current OS or mode."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_LOCALIZATION_MAP_UNAVAILABLE_ML" comment="The localization map requested is not available."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_LOCALIZATION_MAP_FAIL_ML" comment="The map localization service failed to fulfill the request, retry later."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_LOCALIZATION_MAP_IMPORT_EXPORT_PERMISSION_DENIED_ML" comment="The com.magicleap.permission.SPACE_IMPORT_EXPORT permission was denied."/> + <enum offset="4" dir="-" extends="XrResult" name="XR_ERROR_LOCALIZATION_MAP_PERMISSION_DENIED_ML" comment="The com.magicleap.permission.SPACE_MANAGER permission was denied."/> + <enum offset="5" dir="-" extends="XrResult" name="XR_ERROR_LOCALIZATION_MAP_ALREADY_EXISTS_ML" comment="The map being imported already exists in the system."/> + <enum offset="6" dir="-" extends="XrResult" name="XR_ERROR_LOCALIZATION_MAP_CANNOT_EXPORT_CLOUD_MAP_ML" comment="The map localization service cannot export cloud based maps."/> + + <enum offset="0" extends="XrReferenceSpaceType" name="XR_REFERENCE_SPACE_TYPE_LOCALIZATION_MAP_ML"/> + + <enum value="64" name="XR_MAX_LOCALIZATION_MAP_NAME_LENGTH_ML"/> + + <type name="XrLocalizationMapStateML"/> + <type name="XrLocalizationMapTypeML"/> + <type name="XrLocalizationMapConfidenceML"/> + + <type name="XrLocalizationMapML"/> + <type name="XrExportedLocalizationMapML"/> + <type name="XrEventDataLocalizationChangedML"/> + <type name="XrLocalizationMapQueryInfoBaseHeaderML"/> + <type name="XrMapLocalizationRequestInfoML"/> + <type name="XrLocalizationMapImportInfoML"/> + <type name="XrLocalizationEnableEventsInfoML"/> + <type name="XrLocalizationMapErrorFlagsML"/> + <type name="XrLocalizationMapErrorFlagBitsML"/> + + <command name="xrEnableLocalizationEventsML"/> + <command name="xrQueryLocalizationMapsML"/> + <command name="xrRequestMapLocalizationML"/> + <command name="xrImportLocalizationMapML"/> + + <command name="xrCreateExportedLocalizationMapML"/> + <command name="xrDestroyExportedLocalizationMapML"/> + <command name="xrGetExportedLocalizationMapDataML"/> + </require> + </extension> + + <extension name="XR_ML_spatial_anchors" number="141" type="instance" depends="XR_EXT_future" supported="openxr"> + <require> + <enum value="1" name="XR_ML_spatial_anchors_SPEC_VERSION"/> + <enum value=""XR_ML_spatial_anchors"" name="XR_ML_SPATIAL_ANCHORS_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_POSE_ML"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_CREATE_SPATIAL_ANCHORS_COMPLETION_ML"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_STATE_ML"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHORS_PERMISSION_DENIED_ML" comment="The com.magicleap.permission.SPATIAL_ANCHOR permission was not granted."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHORS_NOT_LOCALIZED_ML" comment="Operation failed because the system is not localized into a localization map."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHORS_OUT_OF_MAP_BOUNDS_ML" comment="Operation failed because it is performed outside of the localization map."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHORS_SPACE_NOT_LOCATABLE_ML" comment="Operation failed because the space referenced cannot be located."/> + + + <type name="XrSpatialAnchorsCreateInfoBaseHeaderML"/> + <type name="XrSpatialAnchorsCreateInfoFromPoseML"/> + <type name="XrCreateSpatialAnchorsCompletionML"/> + <type name="XrSpatialAnchorStateML"/> + <type name="XrSpatialAnchorConfidenceML"/> + + <command name="xrCreateSpatialAnchorsAsyncML"/> + <command name="xrCreateSpatialAnchorsCompleteML"/> + <command name="xrGetSpatialAnchorStateML"/> + + </require> + </extension> + + <extension name="XR_ML_spatial_anchors_storage" number="142" type="instance" depends="XR_EXT_future+XR_ML_spatial_anchors" supported="openxr"> + <require> + <enum value="1" name="XR_ML_spatial_anchors_storage_SPEC_VERSION"/> + <enum value=""XR_ML_spatial_anchors_storage"" name="XR_ML_SPATIAL_ANCHORS_STORAGE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SPATIAL_ANCHORS_STORAGE_ML" comment="XrSpatialAnchorsStorageML"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHORS_ANCHOR_NOT_FOUND_ML" comment="The anchor references was not found."/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_CREATE_STORAGE_INFO_ML"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_QUERY_INFO_RADIUS_ML"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_QUERY_COMPLETION_ML"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_UUIDS_ML"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_PUBLISH_INFO_ML"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_PUBLISH_COMPLETION_ML"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_DELETE_INFO_ML"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_DELETE_COMPLETION_ML"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_INFO_ML"/> + <enum offset="9" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_COMPLETION_ML"/> + <enum offset="10" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_PUBLISH_COMPLETION_DETAILS_ML"/> + <enum offset="11" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_DELETE_COMPLETION_DETAILS_ML"/> + <enum offset="12" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_COMPLETION_DETAILS_ML"/> + + <type name="XrSpatialAnchorsStorageML"/> + <type name="XrSpatialAnchorsCreateStorageInfoML"/> + <type name="XrSpatialAnchorsQueryInfoBaseHeaderML"/> + <type name="XrSpatialAnchorsQueryInfoRadiusML"/> + <type name="XrSpatialAnchorsQueryCompletionML"/> + <type name="XrSpatialAnchorsCreateInfoFromUuidsML"/> + <type name="XrSpatialAnchorsPublishInfoML"/> + <type name="XrSpatialAnchorsPublishCompletionML"/> + <type name="XrSpatialAnchorsDeleteInfoML"/> + <type name="XrSpatialAnchorsDeleteCompletionML"/> + <type name="XrSpatialAnchorsUpdateExpirationInfoML"/> + <type name="XrSpatialAnchorsUpdateExpirationCompletionML"/> + <type name="XrSpatialAnchorsPublishCompletionDetailsML"/> + <type name="XrSpatialAnchorsDeleteCompletionDetailsML"/> + <type name="XrSpatialAnchorsUpdateExpirationCompletionDetailsML"/> + <type name="XrSpatialAnchorCompletionResultML"/> + + <command name="xrCreateSpatialAnchorsStorageML"/> + <command name="xrDestroySpatialAnchorsStorageML"/> + <command name="xrQuerySpatialAnchorsAsyncML"/> + <command name="xrQuerySpatialAnchorsCompleteML"/> + <command name="xrPublishSpatialAnchorsAsyncML"/> + <command name="xrPublishSpatialAnchorsCompleteML"/> + <command name="xrDeleteSpatialAnchorsAsyncML"/> + <command name="xrDeleteSpatialAnchorsCompleteML"/> + <command name="xrUpdateSpatialAnchorsExpirationAsyncML"/> + <command name="xrUpdateSpatialAnchorsExpirationCompleteML"/> + + </require> + </extension> + + <extension name="XR_ML_user_calibration" number="473" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ML_user_calibration_SPEC_VERSION"/> + <enum value=""XR_ML_user_calibration"" name="XR_ML_USER_CALIBRATION_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_HEADSET_FIT_CHANGED_ML"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_EYE_CALIBRATION_CHANGED_ML"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_USER_CALIBRATION_ENABLE_EVENTS_INFO_ML"/> + + <type name="XrHeadsetFitStatusML"/> + <type name="XrEyeCalibrationStatusML"/> + + <type name="XrEventDataHeadsetFitChangedML"/> + <type name="XrEventDataEyeCalibrationChangedML"/> + <type name="XrUserCalibrationEnableEventsInfoML"/> + + <command name="xrEnableUserCalibrationEventsML"/> + + </require> + </extension> + + <extension name="XR_MSFT_spatial_anchor_persistence" number="143" depends="XR_VERSION_1_0+XR_MSFT_spatial_anchor" type="instance" supported="openxr" obsoletedby="XR_EXT_spatial_persistence"> + <require> + <enum value="2" name="XR_MSFT_spatial_anchor_persistence_SPEC_VERSION"/> + <enum value=""XR_MSFT_spatial_anchor_persistence"" name="XR_MSFT_SPATIAL_ANCHOR_PERSISTENCE_EXTENSION_NAME"/> + + <type name="XrSpatialAnchorStoreConnectionMSFT"/> + <type name="XrSpatialAnchorPersistenceNameMSFT"/> + <type name="XrSpatialAnchorPersistenceInfoMSFT"/> + <type name="XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT"/> + + <command name="xrCreateSpatialAnchorStoreConnectionMSFT"/> + <command name="xrDestroySpatialAnchorStoreConnectionMSFT"/> + <command name="xrPersistSpatialAnchorMSFT"/> + <command name="xrEnumeratePersistedSpatialAnchorNamesMSFT"/> + <command name="xrCreateSpatialAnchorFromPersistedNameMSFT"/> + <command name="xrUnpersistSpatialAnchorMSFT"/> + <command name="xrClearSpatialAnchorStoreMSFT"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SPATIAL_ANCHOR_STORE_CONNECTION_MSFT" comment="XrSpatialAnchorStoreConnectionMSFT"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_INFO_MSFT"/> + + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHOR_NAME_NOT_FOUND_MSFT" comment="A spatial anchor was not found associated with the spatial anchor name provided"/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT" comment="The spatial anchor name provided was not valid"/> + + <enum value="256" name="XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_MSFT"/> + </require> + </extension> + <extension name="XR_MSFT_extension_144" number="144" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_144_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_144"" name="XR_MSFT_extension_144_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_145" number="145" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_145_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_145"" name="XR_MSFT_extension_145_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_146" number="146" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_146_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_146"" name="XR_MSFT_extension_146_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_147" number="147" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_147_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_147"" name="XR_MSFT_extension_147_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_scene_marker" number="148" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_MSFT_scene_understanding" obsoletedby="XR_EXT_spatial_marker_tracking"> + <require> + <enum value="1" name="XR_MSFT_scene_marker_SPEC_VERSION"/> + <enum value=""XR_MSFT_scene_marker"" name="XR_MSFT_SCENE_MARKER_EXTENSION_NAME"/> + <type name="XrSceneMarkerTypeMSFT"/> + <type name="XrSceneMarkerQRCodeSymbolTypeMSFT"/> + <type name="XrSceneMarkerMSFT"/> + <type name="XrSceneMarkersMSFT"/> + <type name="XrSceneMarkerTypeFilterMSFT"/> + <type name="XrSceneMarkerQRCodeMSFT"/> + <type name="XrSceneMarkerQRCodesMSFT"/> + <enum offset="0" extends="XrSceneComputeFeatureMSFT" name="XR_SCENE_COMPUTE_FEATURE_MARKER_MSFT"/> + <enum offset="0" extends="XrSceneComponentTypeMSFT" name="XR_SCENE_COMPONENT_TYPE_MARKER_MSFT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SCENE_MARKERS_MSFT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SCENE_MARKER_TYPE_FILTER_MSFT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SCENE_MARKER_QR_CODES_MSFT"/> + <enum offset="0" extends="XrResult" name="XR_SCENE_MARKER_DATA_NOT_STRING_MSFT" comment="Marker does not encode a string."/> + <command name="xrGetSceneMarkerRawDataMSFT"/> + <command name="xrGetSceneMarkerDecodedStringMSFT"/> + </require> + </extension> + + <extension name="XR_KHR_extended_struct_name_lengths" number="149" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="2" name="XR_KHR_extended_struct_name_lengths_SPEC_VERSION"/> + <enum value=""XR_KHR_extended_struct_name_lengths"" name="XR_KHR_EXTENDED_STRUCT_NAME_LENGTHS_EXTENSION_NAME"/> + <command name="xrStructureTypeToString2KHR"/> + <enum value="256" name="XR_MAX_STRUCTURE_NAME_SIZE_EXTENDED_KHR"/> + </require> + </extension> + + <extension name="XR_ULTRALEAP_hand_tracking_forearm" number="150" depends="XR_VERSION_1_0+XR_EXT_hand_tracking" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ULTRALEAP_hand_tracking_forearm_SPEC_VERSION"/> + <enum value=""XR_ULTRALEAP_hand_tracking_forearm"" name="XR_ULTRALEAP_HAND_TRACKING_FOREARM_EXTENSION_NAME"/> + + <type name="XrHandForearmJointULTRALEAP"/> + <type name="XR_HAND_FOREARM_JOINT_COUNT_ULTRALEAP"/> + + <enum offset="0" extends="XrHandJointSetEXT" name="XR_HAND_JOINT_SET_HAND_WITH_FOREARM_ULTRALEAP"/> + </require> + </extension> + + <extension name="XR_ULTRALEAP_extension_151" number="151" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ULTRALEAP_extension_151_SPEC_VERSION"/> + <enum value=""XR_ULTRALEAP_extension_151"" name="XR_ULTRALEAP_extension_151_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ULTRALEAP_extension_152" number="152" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ULTRALEAP_extension_152_SPEC_VERSION"/> + <enum value=""XR_ULTRALEAP_extension_152"" name="XR_ULTRALEAP_extension_152_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ULTRALEAP_extension_153" number="153" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ULTRALEAP_extension_153_SPEC_VERSION"/> + <enum value=""XR_ULTRALEAP_extension_153"" name="XR_ULTRALEAP_extension_153_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ULTRALEAP_extension_154" number="154" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ULTRALEAP_extension_154_SPEC_VERSION"/> + <enum value=""XR_ULTRALEAP_extension_154"" name="XR_ULTRALEAP_extension_154_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ULTRALEAP_extension_155" number="155" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ULTRALEAP_extension_155_SPEC_VERSION"/> + <enum value=""XR_ULTRALEAP_extension_155"" name="XR_ULTRALEAP_extension_155_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_156" number="156" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_156_SPEC_VERSION"/> + <enum value=""XR_FB_extension_156"" name="XR_FB_extension_156_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_spatial_entity_query" number="157" type="instance" depends="XR_VERSION_1_0+XR_FB_spatial_entity_storage" supported="openxr"> + <require> + <enum value="1" name="XR_FB_spatial_entity_query_SPEC_VERSION"/> + <enum value=""XR_FB_spatial_entity_query"" name="XR_FB_SPATIAL_ENTITY_QUERY_EXTENSION_NAME"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPACE_QUERY_INFO_FB"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPACE_QUERY_RESULTS_FB"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPACE_STORAGE_LOCATION_FILTER_INFO_FB"/> + <enum offset="54" extends="XrStructureType" name="XR_TYPE_SPACE_UUID_FILTER_INFO_FB"/> + <enum offset="52" extends="XrStructureType" name="XR_TYPE_SPACE_COMPONENT_FILTER_INFO_FB"/> + <enum offset="103" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPACE_QUERY_RESULTS_AVAILABLE_FB"/> + <enum offset="104" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPACE_QUERY_COMPLETE_FB"/> + + <type name="XrSpaceQueryActionFB"/> + + <type name="XrSpaceQueryInfoBaseHeaderFB"/> + <type name="XrSpaceFilterInfoBaseHeaderFB"/> + <type name="XrSpaceQueryInfoFB"/> + <type name="XrSpaceStorageLocationFilterInfoFB"/> + <type name="XrSpaceUuidFilterInfoFB"/> + <type name="XrSpaceComponentFilterInfoFB"/> + <type name="XrSpaceQueryResultFB"/> + <type name="XrSpaceQueryResultsFB"/> + + <type name="XrEventDataSpaceQueryResultsAvailableFB"/> + <type name="XrEventDataSpaceQueryCompleteFB"/> + + <command name="xrQuerySpacesFB"/> + <command name="xrRetrieveSpaceQueryResultsFB"/> + </require> + </extension> + + <extension name="XR_FB_extension_158" number="158" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_158_SPEC_VERSION"/> + <enum value=""XR_FB_extension_158"" name="XR_FB_extension_158_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_spatial_entity_storage" number="159" type="instance" depends="XR_VERSION_1_0+XR_FB_spatial_entity" supported="openxr"> + <require> + <enum value="1" name="XR_FB_spatial_entity_storage_SPEC_VERSION"/> + <enum value=""XR_FB_spatial_entity_storage"" name="XR_FB_SPATIAL_ENTITY_STORAGE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPACE_SAVE_INFO_FB"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPACE_ERASE_INFO_FB"/> + <enum offset="106" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPACE_SAVE_COMPLETE_FB"/> + <enum offset="107" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPACE_ERASE_COMPLETE_FB"/> + + <type name="XrSpaceStorageLocationFB"/> + <type name="XrSpacePersistenceModeFB"/> + + <type name="XrSpaceSaveInfoFB"/> + <type name="XrSpaceEraseInfoFB"/> + + <type name="XrEventDataSpaceSaveCompleteFB"/> + <type name="XrEventDataSpaceEraseCompleteFB"/> + + <command name="xrSaveSpaceFB"/> + <command name="xrEraseSpaceFB"/> + </require> + </extension> + + <extension name="XR_OCULUS_audio_device_guid" number="160" type="instance" supported="openxr" protect="XR_USE_PLATFORM_WIN32"> + <require> + <enum value="1" name="XR_OCULUS_audio_device_guid_SPEC_VERSION"/> + <enum value=""XR_OCULUS_audio_device_guid"" name="XR_OCULUS_AUDIO_DEVICE_GUID_EXTENSION_NAME"/> + <enum value="128" name="XR_MAX_AUDIO_DEVICE_STR_SIZE_OCULUS"/> + <command name="xrGetAudioOutputDeviceGuidOculus"/> + <command name="xrGetAudioInputDeviceGuidOculus"/> + </require> + </extension> + + <extension name="XR_FB_foveation_vulkan" number="161" type="instance" depends="XR_VERSION_1_0+XR_FB_foveation" protect="XR_USE_GRAPHICS_API_VULKAN" supported="openxr"> + <require> + <enum value="1" name="XR_FB_foveation_vulkan_SPEC_VERSION"/> + <enum value=""XR_FB_foveation_vulkan"" name="XR_FB_FOVEATION_VULKAN_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_IMAGE_FOVEATION_VULKAN_FB"/> + + <type name="XrSwapchainImageFoveationVulkanFB"/> + </require> + </extension> + + <extension name="XR_FB_swapchain_update_state_android_surface" number="162" type="instance" supported="openxr" protect="XR_USE_PLATFORM_ANDROID" depends="XR_VERSION_1_0+XR_KHR_android_surface_swapchain+XR_FB_swapchain_update_state"> + <require> + <enum value="1" name="XR_FB_swapchain_update_state_android_surface_SPEC_VERSION"/> + <enum value=""XR_FB_swapchain_update_state_android_surface"" name="XR_FB_SWAPCHAIN_UPDATE_STATE_ANDROID_SURFACE_EXTENSION_NAME"/> + <type name="XrSwapchainStateAndroidSurfaceDimensionsFB"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_STATE_ANDROID_SURFACE_DIMENSIONS_FB"/> + </require> + </extension> + + <extension name="XR_FB_swapchain_update_state_opengl_es" number="163" type="instance" supported="openxr" protect="XR_USE_GRAPHICS_API_OPENGL_ES" depends="XR_KHR_opengl_es_enable+XR_FB_swapchain_update_state"> + <require> + <enum value="1" name="XR_FB_swapchain_update_state_opengl_es_SPEC_VERSION"/> + <enum value=""XR_FB_swapchain_update_state_opengl_es"" name="XR_FB_SWAPCHAIN_UPDATE_STATE_OPENGL_ES_EXTENSION_NAME"/> + <type name="XrSwapchainStateSamplerOpenGLESFB"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_STATE_SAMPLER_OPENGL_ES_FB"/> + </require> + </extension> + + <extension name="XR_FB_swapchain_update_state_vulkan" number="164" type="instance" supported="openxr" protect="XR_USE_GRAPHICS_API_VULKAN" depends="XR_VERSION_1_0+XR_KHR_vulkan_enable+XR_FB_swapchain_update_state"> + <require> + <enum value="1" name="XR_FB_swapchain_update_state_vulkan_SPEC_VERSION"/> + <enum value=""XR_FB_swapchain_update_state_vulkan"" name="XR_FB_SWAPCHAIN_UPDATE_STATE_VULKAN_EXTENSION_NAME"/> + <type name="XrSwapchainStateSamplerVulkanFB"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_STATE_SAMPLER_VULKAN_FB"/> + </require> + </extension> + + <extension name="XR_FB_extension_165" number="165" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_165_SPEC_VERSION"/> + <enum value=""XR_FB_extension_165"" name="XR_FB_extension_165_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_KHR_swapchain_usage_input_attachment_bit" number="166" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="3" name="XR_KHR_swapchain_usage_input_attachment_bit_SPEC_VERSION"/> + <enum value=""XR_KHR_swapchain_usage_input_attachment_bit"" name="XR_KHR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_EXTENSION_NAME"/> + <enum extends="XrSwapchainUsageFlagBits" name="XR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_KHR" alias="XR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_MND" comment="Specifies that the image may: be used as a input attachment."/> + </require> + </extension> + + <extension name="XR_FB_extension_167" number="167" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_167_SPEC_VERSION"/> + <enum value=""XR_FB_extension_167"" name="XR_FB_extension_167_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_touch_controller_pro" number="168" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="1" name="XR_FB_touch_controller_pro_SPEC_VERSION"/> + <enum value=""XR_FB_touch_controller_pro"" name="XR_FB_TOUCH_CONTROLLER_PRO_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/facebook/touch_controller_pro"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/facebook/touch_controller_pro"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/facebook/touch_controller_pro"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/facebook/touch_controller_pro"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_FB_extension_169" number="169" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_169_SPEC_VERSION"/> + <enum value=""XR_FB_extension_169"" name="XR_FB_extension_169_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_spatial_entity_sharing" number="170" type="instance" depends="XR_VERSION_1_0+XR_FB_spatial_entity" supported="openxr"> + <require> + <enum value="1" name="XR_FB_spatial_entity_sharing_SPEC_VERSION"/> + <enum value=""XR_FB_spatial_entity_sharing"" name="XR_FB_SPATIAL_ENTITY_SHARING_EXTENSION_NAME"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPACE_SHARE_INFO_FB"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPACE_SHARE_COMPLETE_FB"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SPACE_MAPPING_INSUFFICIENT_FB" comment="Anchor import from cloud or export from device failed."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPACE_LOCALIZATION_FAILED_FB" comment="Anchors were downloaded from the cloud but failed to be imported/aligned on the device."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_SPACE_NETWORK_TIMEOUT_FB" comment="Timeout occurred while waiting for network request to complete."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_SPACE_NETWORK_REQUEST_FAILED_FB" comment="The network request failed."/> + <enum offset="4" dir="-" extends="XrResult" name="XR_ERROR_SPACE_CLOUD_STORAGE_DISABLED_FB" comment="Cloud storage is required for this operation but is currently disabled."/> + + <type name="XrSpaceShareInfoFB"/> + <type name="XrEventDataSpaceShareCompleteFB"/> + + <command name="xrShareSpacesFB"/> + </require> + </extension> + + <extension name="XR_FB_extension_171" number="171" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_171_SPEC_VERSION"/> + <enum value=""XR_FB_extension_171"" name="XR_FB_extension_171_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_space_warp" number="172" type="instance" supported="openxr" deprecatedby="XR_EXT_frame_synthesis"> + <require> + <enum value="2" name="XR_FB_space_warp_SPEC_VERSION"/> + <enum value=""XR_FB_space_warp"" name="XR_FB_SPACE_WARP_EXTENSION_NAME"/> + <type name="XrCompositionLayerSpaceWarpInfoFB"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_SPACE_WARP_INFO_FB"/> + <type name="XrSystemSpaceWarpPropertiesFB"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPACE_WARP_PROPERTIES_FB"/> + <type name="XrCompositionLayerSpaceWarpInfoFlagsFB"/> + <type name="XrCompositionLayerSpaceWarpInfoFlagBitsFB"/> + </require> + </extension> + + <extension name="XR_FB_extension_173" number="173" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_173_SPEC_VERSION"/> + <enum value=""XR_FB_extension_173"" name="XR_FB_extension_173_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_haptic_amplitude_envelope" number="174" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_haptic_amplitude_envelope_SPEC_VERSION"/> + <enum value=""XR_FB_haptic_amplitude_envelope"" name="XR_FB_HAPTIC_AMPLITUDE_ENVELOPE_EXTENSION_NAME"/> + <type name="XrHapticAmplitudeEnvelopeVibrationFB"/> + <type name="XR_MAX_HAPTIC_AMPLITUDE_ENVELOPE_SAMPLES_FB"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_HAPTIC_AMPLITUDE_ENVELOPE_VIBRATION_FB"/> + </require> + </extension> + + <extension name="XR_FB_extension_175" number="175" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_175_SPEC_VERSION"/> + <enum value=""XR_FB_extension_175"" name="XR_FB_extension_175_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_scene" number="176" type="instance" depends="XR_VERSION_1_0+XR_FB_spatial_entity" supported="openxr"> + <require> + <enum value="4" name="XR_FB_scene_SPEC_VERSION"/> + <enum value=""XR_FB_scene"" name="XR_FB_SCENE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SEMANTIC_LABELS_FB"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_ROOM_LAYOUT_FB"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_BOUNDARY_2D_FB"/> + <enum offset="10" extends="XrStructureType" name="XR_TYPE_SEMANTIC_LABELS_SUPPORT_INFO_FB"/> + + <type name="XrExtent3DfFB"/> + <type name="XrOffset3DfFB"/> + <type name="XrRect3DfFB"/> + <type name="XrSemanticLabelsFB"/> + <type name="XrRoomLayoutFB"/> + <type name="XrBoundary2DFB"/> + <type name="XrSemanticLabelsSupportInfoFB"/> + + <type name="XrSemanticLabelsSupportFlagsFB"/> + <type name="XrSemanticLabelsSupportFlagBitsFB"/> + + <command name="xrGetSpaceBoundingBox2DFB"/> + <command name="xrGetSpaceBoundingBox3DFB"/> + <command name="xrGetSpaceSemanticLabelsFB"/> + <command name="xrGetSpaceBoundary2DFB"/> + <command name="xrGetSpaceRoomLayoutFB"/> + + </require> + </extension> + + <extension name="XR_EXT_palm_pose" number="177" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="3" name="XR_EXT_palm_pose_SPEC_VERSION"/> + <enum value=""XR_EXT_palm_pose"" name="XR_EXT_PALM_POSE_EXTENSION_NAME"/> + + <!-- + Only core 1.0 interaction profiles get extended here. + Others get this pose added in a nested <require depends="XR_EXT_palm_pose"> + inside the extension and/or feature that adds them. + --> + <extend interaction_profile_path="/interaction_profiles/khr/simple_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/google/daydream_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/htc/vive_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/microsoft/motion_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/oculus/go_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/oculus/touch_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/valve/index_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_UNITY_extension_178" number="178" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_UNITY_extension_178_SPEC_VERSION"/> + <enum value=""XR_UNITY_extension_178"" name="XR_UNITY_EXTENSION_178_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_UNITY_extension_179" number="179" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_UNITY_extension_179_SPEC_VERSION"/> + <enum value=""XR_UNITY_extension_179"" name="XR_UNITY_EXTENSION_179_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_UNITY_extension_180" number="180" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_UNITY_extension_180_SPEC_VERSION"/> + <enum value=""XR_UNITY_extension_180"" name="XR_UNITY_EXTENSION_180_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_UNITY_extension_181" number="181" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_UNITY_extension_181_SPEC_VERSION"/> + <enum value=""XR_UNITY_extension_181"" name="XR_UNITY_EXTENSION_181_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_UNITY_extension_182" number="182" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_UNITY_extension_182_SPEC_VERSION"/> + <enum value=""XR_UNITY_extension_182"" name="XR_UNITY_EXTENSION_182_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_UNITY_extension_183" number="183" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_UNITY_extension_183_SPEC_VERSION"/> + <enum value=""XR_UNITY_extension_183"" name="XR_UNITY_EXTENSION_183_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_UNITY_extension_184" number="184" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_UNITY_extension_184_SPEC_VERSION"/> + <enum value=""XR_UNITY_extension_184"" name="XR_UNITY_EXTENSION_184_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_UNITY_extension_185" number="185" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_UNITY_extension_185_SPEC_VERSION"/> + <enum value=""XR_UNITY_extension_185"" name="XR_UNITY_EXTENSION_185_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_UNITY_extension_186" number="186" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_UNITY_extension_186_SPEC_VERSION"/> + <enum value=""XR_UNITY_extension_186"" name="XR_UNITY_EXTENSION_186_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LIV_extension_187" number="187" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LIV_extension_187_SPEC_VERSION"/> + <enum value=""XR_LIV_extension_187"" name="XR_LIV_EXTENSION_187_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LIV_extension_188" number="188" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LIV_extension_188_SPEC_VERSION"/> + <enum value=""XR_LIV_extension_188"" name="XR_LIV_EXTENSION_188_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LIV_extension_189" number="189" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LIV_extension_189_SPEC_VERSION"/> + <enum value=""XR_LIV_extension_189"" name="XR_LIV_EXTENSION_189_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LIV_extension_190" number="190" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LIV_extension_190_SPEC_VERSION"/> + <enum value=""XR_LIV_extension_190"" name="XR_LIV_EXTENSION_190_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LIV_extension_191" number="191" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LIV_extension_191_SPEC_VERSION"/> + <enum value=""XR_LIV_extension_191"" name="XR_LIV_EXTENSION_191_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LIV_extension_192" number="192" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LIV_extension_192_SPEC_VERSION"/> + <enum value=""XR_LIV_extension_192"" name="XR_LIV_EXTENSION_192_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LIV_extension_193" number="193" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LIV_extension_193_SPEC_VERSION"/> + <enum value=""XR_LIV_extension_193"" name="XR_LIV_EXTENSION_193_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LIV_extension_194" number="194" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LIV_extension_194_SPEC_VERSION"/> + <enum value=""XR_LIV_extension_194"" name="XR_LIV_EXTENSION_194_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LIV_extension_195" number="195" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LIV_extension_195_SPEC_VERSION"/> + <enum value=""XR_LIV_extension_195"" name="XR_LIV_EXTENSION_195_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LIV_extension_196" number="196" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LIV_extension_196_SPEC_VERSION"/> + <enum value=""XR_LIV_extension_196"" name="XR_LIV_EXTENSION_196_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ALMALENCE_digital_lens_control" number="197" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ALMALENCE_digital_lens_control_SPEC_VERSION"/> + <enum value=""XR_ALMALENCE_digital_lens_control"" name="XR_ALMALENCE_DIGITAL_LENS_CONTROL_EXTENSION_NAME"/> + + <type name="XrDigitalLensControlALMALENCE"/> + <type name="XrDigitalLensControlFlagsALMALENCE"/> + <type name="XrDigitalLensControlFlagBitsALMALENCE"/> + + <command name="xrSetDigitalLensControlALMALENCE"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_DIGITAL_LENS_CONTROL_ALMALENCE"/> + </require> + </extension> + + <extension name="XR_FB_extension_198" number="198" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_198_SPEC_VERSION"/> + <enum value=""XR_FB_extension_198"" name="XR_FB_EXTENSION_198_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_scene_capture" number="199" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_scene_capture_SPEC_VERSION"/> + <enum value=""XR_FB_scene_capture"" name="XR_FB_SCENE_CAPTURE_EXTENSION_NAME"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SCENE_CAPTURE_COMPLETE_FB"/> + <enum offset="50" extends="XrStructureType" name="XR_TYPE_SCENE_CAPTURE_REQUEST_INFO_FB"/> + + <type name="XrEventDataSceneCaptureCompleteFB"/> + <type name="XrSceneCaptureRequestInfoFB"/> + + <command name="xrRequestSceneCaptureFB"/> + + </require> + </extension> + + <extension name="XR_FB_spatial_entity_container" number="200" type="instance" depends="XR_VERSION_1_0+XR_FB_spatial_entity" supported="openxr"> + <require> + <enum value="2" name="XR_FB_spatial_entity_container_SPEC_VERSION"/> + <enum value=""XR_FB_spatial_entity_container"" name="XR_FB_SPATIAL_ENTITY_CONTAINER_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPACE_CONTAINER_FB"/> + + <type name="XrSpaceContainerFB"/> + + <command name="xrGetSpaceContainerFB"/> + </require> + </extension> + + <extension name="XR_META_foveation_eye_tracked" number="201" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_FB_foveation+XR_FB_foveation_configuration"> + <require> + <enum value="1" name="XR_META_foveation_eye_tracked_SPEC_VERSION"/> + <enum value=""XR_META_foveation_eye_tracked"" name="XR_META_FOVEATION_EYE_TRACKED_EXTENSION_NAME"/> + <enum value="2" name="XR_FOVEATION_CENTER_SIZE_META"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_FOVEATION_EYE_TRACKED_PROFILE_CREATE_INFO_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_FOVEATION_EYE_TRACKED_STATE_META"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SYSTEM_FOVEATION_EYE_TRACKED_PROPERTIES_META"/> + + <type name="XrFoveationEyeTrackedProfileCreateInfoMETA"/> + <type name="XrFoveationEyeTrackedStateMETA"/> + <type name="XrSystemFoveationEyeTrackedPropertiesMETA"/> + + <type name="XrFoveationEyeTrackedProfileCreateFlagsMETA"/> + <type name="XrFoveationEyeTrackedProfileCreateFlagBitsMETA"/> + + <type name="XrFoveationEyeTrackedStateFlagsMETA"/> + <type name="XrFoveationEyeTrackedStateFlagBitsMETA"/> + + <command name="xrGetFoveationEyeTrackedStateMETA"/> + </require> + </extension> + + <extension name="XR_FB_face_tracking" number="202" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_face_tracking_SPEC_VERSION"/> + <enum value=""XR_FB_face_tracking"" name="XR_FB_FACE_TRACKING_EXTENSION_NAME"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_FACE_TRACKER_FB" comment="XrFaceTrackerFB"/> + <type name="XrFaceTrackerFB"/> + + <type name="XrFaceExpressionFB"/> + <type name="XrFaceExpressionSetFB"/> + <type name="XrFaceConfidenceFB"/> + <type name="XR_FACE_EXPRESSSION_SET_DEFAULT_FB"/> + + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES_FB"/> + <type name="XrSystemFaceTrackingPropertiesFB"/> + + <enum offset="5" extends="XrStructureType" name="XR_TYPE_FACE_TRACKER_CREATE_INFO_FB"/> + <type name="XrFaceTrackerCreateInfoFB"/> + + <enum offset="2" extends="XrStructureType" name="XR_TYPE_FACE_EXPRESSION_INFO_FB"/> + <type name="XrFaceExpressionInfoFB"/> + + <type name="XrFaceExpressionStatusFB"/> + + <enum offset="6" extends="XrStructureType" name="XR_TYPE_FACE_EXPRESSION_WEIGHTS_FB"/> + <type name="XrFaceExpressionWeightsFB"/> + + <command name="xrCreateFaceTrackerFB"/> + <command name="xrDestroyFaceTrackerFB"/> + <command name="xrGetFaceExpressionWeightsFB"/> + </require> + </extension> + + <extension name="XR_FB_eye_tracking_social" number="203" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_eye_tracking_social_SPEC_VERSION"/> + <enum value=""XR_FB_eye_tracking_social"" name="XR_FB_EYE_TRACKING_SOCIAL_EXTENSION_NAME"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_EYE_TRACKER_FB" comment="XrEyeTrackerFB"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_EYE_TRACKER_CREATE_INFO_FB"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_EYE_GAZES_INFO_FB"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_EYE_GAZES_FB"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SYSTEM_EYE_TRACKING_PROPERTIES_FB"/> + + <type name="XrEyeTrackerFB"/> + + <type name="XrEyeGazeFB"/> + <type name="XrEyePositionFB"/> + + <type name="XrEyeTrackerCreateInfoFB"/> + <type name="XrEyeGazesInfoFB"/> + <type name="XrSystemEyeTrackingPropertiesFB"/> + <type name="XrEyeGazesFB"/> + + <command name="xrCreateEyeTrackerFB"/> + <command name="xrDestroyEyeTrackerFB"/> + <command name="xrGetEyeGazesFB"/> + </require> + </extension> + + <extension name="XR_FB_passthrough_keyboard_hands" number="204" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_FB_passthrough"> + <require> + <enum value="2" name="XR_FB_passthrough_keyboard_hands_SPEC_VERSION"/> + <enum value=""XR_FB_passthrough_keyboard_hands"" name="XR_FB_PASSTHROUGH_KEYBOARD_HANDS_EXTENSION_NAME"/> + + <enum offset="1" extends="XrPassthroughLayerPurposeFB" name="XR_PASSTHROUGH_LAYER_PURPOSE_TRACKED_KEYBOARD_HANDS_FB" comment="Passthrough layer purpose for keyboard hands presence."/> + <enum offset="2" extends="XrPassthroughLayerPurposeFB" name="XR_PASSTHROUGH_LAYER_PURPOSE_TRACKED_KEYBOARD_MASKED_HANDS_FB" comment="Passthrough layer purpose for keyboard hands presence with keyboard masked hand transitions (i.e passthrough hands rendered only when they are over the keyboard)."/> + + <enum offset="2" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_KEYBOARD_HANDS_INTENSITY_FB"/> + + <type name="XrPassthroughKeyboardHandsIntensityFB"/> + + <command name="xrPassthroughLayerSetKeyboardHandsIntensityFB"/> + </require> + </extension> + + <extension name="XR_FB_composition_layer_settings" number="205" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_composition_layer_settings_SPEC_VERSION"/> + <enum value=""XR_FB_composition_layer_settings"" name="XR_FB_COMPOSITION_LAYER_SETTINGS_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_SETTINGS_FB"/> + <type name="XrCompositionLayerSettingsFB"/> + <type name="XrCompositionLayerSettingsFlagsFB"/> + <type name="XrCompositionLayerSettingsFlagBitsFB"/> + </require> + </extension> + + <extension name="XR_FB_extension_206" number="206" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_206_SPEC_VERSION"/> + <enum value=""XR_FB_extension_206"" name="XR_FB_EXTENSION_206_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_touch_controller_proximity" number="207" type="instance" supported="openxr" obsoletedby="XR_VERSION_1_1"> + <require> + <enum value="1" name="XR_FB_touch_controller_proximity_SPEC_VERSION"/> + <enum value=""XR_FB_touch_controller_proximity"" name="XR_FB_TOUCH_CONTROLLER_PROXIMITY_EXTENSION_NAME"/> + + <extend interaction_profile_path="/interaction_profiles/oculus/touch_controller"> + <component subpath="/input/trigger/proximity_fb" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumb_fb/proximity_fb" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_FB_extension_208" number="208" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_208_SPEC_VERSION"/> + <enum value=""XR_FB_extension_208"" name="XR_FB_EXTENSION_208_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_209" number="209" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_209_SPEC_VERSION"/> + <enum value=""XR_FB_extension_209"" name="XR_FB_EXTENSION_209_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_haptic_pcm" number="210" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_haptic_pcm_SPEC_VERSION"/> + <enum value=""XR_FB_haptic_pcm"" name="XR_FB_HAPTIC_PCM_EXTENSION_NAME"/> + + <type name="XrHapticPcmVibrationFB"/> + <type name="XrDevicePcmSampleRateGetInfoFB"/> + <type name="XrDevicePcmSampleRateStateFB"/> + <type name="XR_MAX_HAPTIC_PCM_BUFFER_SIZE_FB"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_HAPTIC_PCM_VIBRATION_FB"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_DEVICE_PCM_SAMPLE_RATE_STATE_FB"/> + <enum extends="XrStructureType" name="XR_TYPE_DEVICE_PCM_SAMPLE_RATE_GET_INFO_FB" alias="XR_TYPE_DEVICE_PCM_SAMPLE_RATE_STATE_FB"/> + + <command name="xrGetDeviceSampleRateFB"/> + </require> + </extension> + + <extension name="XR_FB_extension_211" number="211" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_211_SPEC_VERSION"/> + <enum value=""XR_FB_extension_211"" name="XR_FB_EXTENSION_211_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_frame_synthesis" number="212" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_EXT_frame_synthesis_SPEC_VERSION"/> + <enum value=""XR_EXT_frame_synthesis"" name="XR_EXT_FRAME_SYNTHESIS_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_FRAME_SYNTHESIS_INFO_EXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_FRAME_SYNTHESIS_CONFIG_VIEW_EXT"/> + <type name="XrFrameSynthesisInfoEXT"/> + <type name="XrFrameSynthesisConfigViewEXT"/> + <type name="XrFrameSynthesisInfoFlagsEXT"/> + <type name="XrFrameSynthesisInfoFlagBitsEXT"/> + </require> + </extension> + + <extension name="XR_FB_composition_layer_depth_test" number="213" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_composition_layer_depth_test_SPEC_VERSION"/> + <enum value=""XR_FB_composition_layer_depth_test"" name="XR_FB_COMPOSITION_LAYER_DEPTH_TEST_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_DEPTH_TEST_FB"/> + + <type name="XrCompareOpFB"/> + <type name="XrCompositionLayerDepthTestFB"/> + + </require> + </extension> + + <extension name="XR_FB_extension_214" number="214" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_214_SPEC_VERSION"/> + <enum value=""XR_FB_extension_214"" name="XR_FB_EXTENSION_214_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_215" number="215" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_215_SPEC_VERSION"/> + <enum value=""XR_FB_extension_215"" name="XR_FB_EXTENSION_215_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_216" number="216" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_216_SPEC_VERSION"/> + <enum value=""XR_FB_extension_216"" name="XR_FB_EXTENSION_216_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_local_dimming" number="217" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_local_dimming_SPEC_VERSION"/> + <enum value=""XR_META_local_dimming"" name="XR_META_LOCAL_DIMMING_EXTENSION_NAME"/> + + <type name="XrLocalDimmingModeMETA"/> + <type name="XrLocalDimmingFrameEndInfoMETA"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_LOCAL_DIMMING_FRAME_END_INFO_META"/> + </require> + </extension> + + <extension name="XR_META_passthrough_preferences" number="218" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_passthrough_preferences_SPEC_VERSION"/> + <enum value=""XR_META_passthrough_preferences"" name="XR_META_PASSTHROUGH_PREFERENCES_EXTENSION_NAME"/> + + <type name="XrPassthroughPreferencesMETA"/> + <type name="XrPassthroughPreferenceFlagsMETA"/> + <type name="XrPassthroughPreferenceFlagBitsMETA"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_PREFERENCES_META"/> + + <command name="xrGetPassthroughPreferencesMETA"/> + </require> + </extension> + + <extension name="XR_FB_extension_219" number="219" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_219_SPEC_VERSION"/> + <enum value=""XR_FB_extension_219"" name="XR_FB_EXTENSION_219_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_virtual_keyboard" number="220" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_virtual_keyboard_SPEC_VERSION"/> + <enum value=""XR_META_virtual_keyboard"" name="XR_META_VIRTUAL_KEYBOARD_EXTENSION_NAME"/> + + <enum value="3992" name="XR_MAX_VIRTUAL_KEYBOARD_COMMIT_TEXT_SIZE_META"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_VIRTUAL_KEYBOARD_META" comment="XrVirtualKeyboardMETA"/> + + <type name="XrVirtualKeyboardLocationTypeMETA"/> + <type name="XrVirtualKeyboardInputSourceMETA"/> + + <type name="XrVirtualKeyboardMETA"/> + <type name="XrSystemVirtualKeyboardPropertiesMETA"/> + <type name="XrVirtualKeyboardCreateInfoMETA"/> + <type name="XrVirtualKeyboardSpaceCreateInfoMETA"/> + <type name="XrVirtualKeyboardLocationInfoMETA"/> + <type name="XrVirtualKeyboardModelVisibilitySetInfoMETA"/> + <type name="XrVirtualKeyboardAnimationStateMETA"/> + <type name="XrVirtualKeyboardModelAnimationStatesMETA"/> + <type name="XrVirtualKeyboardTextureDataMETA"/> + <type name="XrVirtualKeyboardInputInfoMETA"/> + <type name="XrVirtualKeyboardInputStateFlagsMETA"/> + <type name="XrVirtualKeyboardInputStateFlagBitsMETA"/> + <type name="XrVirtualKeyboardTextContextChangeInfoMETA"/> + <type name="XrEventDataVirtualKeyboardCommitTextMETA"/> + <type name="XrEventDataVirtualKeyboardBackspaceMETA"/> + <type name="XrEventDataVirtualKeyboardEnterMETA"/> + <type name="XrEventDataVirtualKeyboardShownMETA"/> + <type name="XrEventDataVirtualKeyboardHiddenMETA"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SYSTEM_VIRTUAL_KEYBOARD_PROPERTIES_META"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_VIRTUAL_KEYBOARD_CREATE_INFO_META"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_VIRTUAL_KEYBOARD_SPACE_CREATE_INFO_META"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_VIRTUAL_KEYBOARD_LOCATION_INFO_META"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_VIRTUAL_KEYBOARD_MODEL_VISIBILITY_SET_INFO_META"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_VIRTUAL_KEYBOARD_ANIMATION_STATE_META"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_VIRTUAL_KEYBOARD_MODEL_ANIMATION_STATES_META"/> + <enum offset="9" extends="XrStructureType" name="XR_TYPE_VIRTUAL_KEYBOARD_TEXTURE_DATA_META"/> + <enum offset="10" extends="XrStructureType" name="XR_TYPE_VIRTUAL_KEYBOARD_INPUT_INFO_META"/> + <enum offset="11" extends="XrStructureType" name="XR_TYPE_VIRTUAL_KEYBOARD_TEXT_CONTEXT_CHANGE_INFO_META"/> + <enum offset="14" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_COMMIT_TEXT_META"/> + <enum offset="15" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_BACKSPACE_META"/> + <enum offset="16" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_ENTER_META"/> + <enum offset="17" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_SHOWN_META"/> + <enum offset="18" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_HIDDEN_META"/> + + <command name="xrCreateVirtualKeyboardMETA"/> + <command name="xrDestroyVirtualKeyboardMETA"/> + <command name="xrCreateVirtualKeyboardSpaceMETA"/> + <command name="xrSuggestVirtualKeyboardLocationMETA"/> + <command name="xrGetVirtualKeyboardScaleMETA"/> + <command name="xrSetVirtualKeyboardModelVisibilityMETA"/> + <command name="xrGetVirtualKeyboardModelAnimationStatesMETA"/> + <command name="xrGetVirtualKeyboardDirtyTexturesMETA"/> + <command name="xrGetVirtualKeyboardTextureDataMETA"/> + <command name="xrSendVirtualKeyboardInputMETA"/> + <command name="xrChangeVirtualKeyboardTextContextMETA"/> + </require> + </extension> + + <extension name="XR_FB_extension_221" number="221" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_221_SPEC_VERSION"/> + <enum value=""XR_FB_extension_221"" name="XR_FB_EXTENSION_221_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_222" number="222" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_222_SPEC_VERSION"/> + <enum value=""XR_FB_extension_222"" name="XR_FB_EXTENSION_222_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_223" number="223" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_223_SPEC_VERSION"/> + <enum value=""XR_FB_extension_223"" name="XR_FB_EXTENSION_223_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_224" number="224" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_224_SPEC_VERSION"/> + <enum value=""XR_FB_extension_224"" name="XR_FB_EXTENSION_224_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_225" number="225" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_225_SPEC_VERSION"/> + <enum value=""XR_FB_extension_225"" name="XR_FB_EXTENSION_225_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_226" number="226" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_226_SPEC_VERSION"/> + <enum value=""XR_FB_extension_226"" name="XR_FB_EXTENSION_226_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_OCULUS_external_camera" number="227" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_OCULUS_external_camera_SPEC_VERSION"/> + <enum value=""XR_OCULUS_external_camera"" name="XR_OCULUS_EXTERNAL_CAMERA_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_EXTERNAL_CAMERA_OCULUS"/> + + <enum value="32" name="XR_MAX_EXTERNAL_CAMERA_NAME_SIZE_OCULUS"/> + + <type name="XrExternalCameraAttachedToDeviceOCULUS"/> + + <type name="XrExternalCameraIntrinsicsOCULUS"/> + <type name="XrExternalCameraExtrinsicsOCULUS"/> + <type name="XrExternalCameraOCULUS"/> + <type name="XrExternalCameraStatusFlagsOCULUS"/> + <type name="XrExternalCameraStatusFlagBitsOCULUS"/> + + <command name="xrEnumerateExternalCamerasOCULUS"/> + </require> + </extension> + + <extension name="XR_META_vulkan_swapchain_create_info" number="228" type="instance" protect="XR_USE_GRAPHICS_API_VULKAN" supported="openxr"> + <require> + <enum value="1" name="XR_META_vulkan_swapchain_create_info_SPEC_VERSION"/> + <enum value=""XR_META_vulkan_swapchain_create_info"" name="XR_META_VULKAN_SWAPCHAIN_CREATE_INFO_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_VULKAN_SWAPCHAIN_CREATE_INFO_META"/> + + <type name="XrVulkanSwapchainCreateInfoMETA"/> + </require> + </extension> + + <extension name="XR_FB_extension_229" number="229" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_229_SPEC_VERSION"/> + <enum value=""XR_FB_extension_229"" name="XR_FB_EXTENSION_229_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_230" number="230" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_230_SPEC_VERSION"/> + <enum value=""XR_FB_extension_230"" name="XR_FB_EXTENSION_230_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_231" number="231" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_231_SPEC_VERSION"/> + <enum value=""XR_FB_extension_231"" name="XR_FB_EXTENSION_231_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_232" number="232" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_232_SPEC_VERSION"/> + <enum value=""XR_FB_extension_232"" name="XR_FB_EXTENSION_232_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_performance_metrics" number="233" type="instance" supported="openxr"> + <require> + <enum value="2" name="XR_META_performance_metrics_SPEC_VERSION"/> + <enum value=""XR_META_performance_metrics"" name="XR_META_PERFORMANCE_METRICS_EXTENSION_NAME"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_PERFORMANCE_METRICS_STATE_META"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_PERFORMANCE_METRICS_COUNTER_META"/> + + <type name="XrPerformanceMetricsStateMETA"/> + <type name="XrPerformanceMetricsCounterMETA"/> + <type name="XrPerformanceMetricsCounterFlagsMETA"/> + <type name="XrPerformanceMetricsCounterFlagBitsMETA"/> + + <type name="XrPerformanceMetricsCounterUnitMETA"/> + + <command name="xrEnumeratePerformanceMetricsCounterPathsMETA"/> + <command name="xrSetPerformanceMetricsStateMETA"/> + <command name="xrGetPerformanceMetricsStateMETA"/> + <command name="xrQueryPerformanceMetricsCounterMETA"/> + </require> + </extension> + + <extension name="XR_FB_extension_234" number="234" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_234_SPEC_VERSION"/> + <enum value=""XR_FB_extension_234"" name="XR_FB_EXTENSION_234_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_235" number="235" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_235_SPEC_VERSION"/> + <enum value=""XR_FB_extension_235"" name="XR_FB_EXTENSION_235_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_236" number="236" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_236_SPEC_VERSION"/> + <enum value=""XR_FB_extension_236"" name="XR_FB_EXTENSION_236_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_237" number="237" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_237_SPEC_VERSION"/> + <enum value=""XR_FB_extension_237"" name="XR_FB_EXTENSION_237_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_238" number="238" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_238_SPEC_VERSION"/> + <enum value=""XR_FB_extension_238"" name="XR_FB_EXTENSION_238_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_spatial_entity_storage_batch" number="239" type="instance" depends="XR_VERSION_1_0+XR_FB_spatial_entity_storage" supported="openxr"> + <require> + <enum value="1" name="XR_FB_spatial_entity_storage_batch_SPEC_VERSION"/> + <enum value=""XR_FB_spatial_entity_storage_batch"" name="XR_FB_SPATIAL_ENTITY_STORAGE_BATCH_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPACE_LIST_SAVE_INFO_FB"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPACE_LIST_SAVE_COMPLETE_FB"/> + + <type name="XrSpaceListSaveInfoFB"/> + <type name="XrEventDataSpaceListSaveCompleteFB"/> + + <command name="xrSaveSpaceListFB"/> + </require> + </extension> + + <extension name="XR_FB_extension_240" number="240" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_240_SPEC_VERSION"/> + <enum value=""XR_FB_extension_240"" name="XR_FB_EXTENSION_240_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_detached_controllers" number="241" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_detached_controllers_SPEC_VERSION"/> + <enum value=""XR_META_detached_controllers"" name="XR_META_DETACHED_CONTROLLERS_EXTENSION_NAME"/> + + <extend interaction_profile_predicate="true"> + <condition> + <user_path path="/user/hand/left"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </condition> + <user_path path="/user/detached_controller_meta/left" inherit="/user/hand/left"/> + </extend> + + <extend interaction_profile_predicate="true"> + <condition> + <user_path path="/user/hand/right"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </condition> + <user_path path="/user/detached_controller_meta/right" inherit="/user/hand/right"/> + </extend> + + </require> + </extension> + + <extension name="XR_FB_spatial_entity_user" number="242" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_spatial_entity_user_SPEC_VERSION"/> + <enum value=""XR_FB_spatial_entity_user"" name="XR_FB_SPATIAL_ENTITY_USER_EXTENSION_NAME"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPACE_USER_CREATE_INFO_FB"/> + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SPACE_USER_FB" comment="XrSpaceUserFB"/> + + <type name="XrSpaceUserFB"/> + <type name="XrSpaceUserIdFB"/> + <type name="XrSpaceUserCreateInfoFB"/> + + <command name="xrCreateSpaceUserFB"/> + <command name="xrGetSpaceUserIdFB"/> + <command name="xrDestroySpaceUserFB"/> + </require> + </extension> + + <extension name="XR_FB_extension_243" number="243" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_243_SPEC_VERSION"/> + <enum value=""XR_FB_extension_243"" name="XR_FB_EXTENSION_243_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_244" number="244" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_244_SPEC_VERSION"/> + <enum value=""XR_FB_extension_244"" name="XR_FB_EXTENSION_244_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_245" number="245" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_245_SPEC_VERSION"/> + <enum value=""XR_FB_extension_245"" name="XR_FB_EXTENSION_245_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_headset_id" number="246" type="instance" supported="openxr"> + <require> + <enum value="2" name="XR_META_headset_id_SPEC_VERSION"/> + <enum value=""XR_META_headset_id"" name="XR_META_HEADSET_ID_EXTENSION_NAME"/> + + <type name="XrSystemHeadsetIdPropertiesMETA"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_HEADSET_ID_PROPERTIES_META"/> + </require> + </extension> + + <extension name="XR_FB_extension_247" number="247" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_247_SPEC_VERSION"/> + <enum value=""XR_FB_extension_247"" name="XR_FB_EXTENSION_247_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_spatial_entity_discovery" number="248" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_spatial_entity_discovery_SPEC_VERSION"/> + <enum value=""XR_META_spatial_entity_discovery"" name="XR_META_SPATIAL_ENTITY_DISCOVERY_EXTENSION_NAME"/> + + <type name="XrSystemSpaceDiscoveryPropertiesMETA"/> + <type name="XrSpaceFilterBaseHeaderMETA"/> + <type name="XrSpaceDiscoveryInfoMETA"/> + <type name="XrSpaceFilterUuidMETA"/> + <type name="XrSpaceFilterComponentMETA"/> + <type name="XrSpaceDiscoveryResultMETA"/> + <type name="XrSpaceDiscoveryResultsMETA"/> + <type name="XrEventDataSpaceDiscoveryResultsAvailableMETA"/> + <type name="XrEventDataSpaceDiscoveryCompleteMETA"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPACE_DISCOVERY_PROPERTIES_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPACE_DISCOVERY_INFO_META"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPACE_FILTER_UUID_META"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SPACE_FILTER_COMPONENT_META"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_SPACE_DISCOVERY_RESULT_META"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_SPACE_DISCOVERY_RESULTS_META"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPACE_DISCOVERY_RESULTS_AVAILABLE_META"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPACE_DISCOVERY_COMPLETE_META"/> + + <command name="xrDiscoverSpacesMETA"/> + <command name="xrRetrieveSpaceDiscoveryResultsMETA"/> + </require> + </extension> + + <extension name="XR_FB_extension_249" number="249" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_249_SPEC_VERSION"/> + <enum value=""XR_FB_extension_249"" name="XR_FB_EXTENSION_249_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_250" number="250" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_250_SPEC_VERSION"/> + <enum value=""XR_FB_extension_250"" name="XR_FB_EXTENSION_250_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_251" number="251" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_251_SPEC_VERSION"/> + <enum value=""XR_FB_extension_251"" name="XR_FB_EXTENSION_251_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_252" number="252" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_252_SPEC_VERSION"/> + <enum value=""XR_FB_extension_252"" name="XR_FB_EXTENSION_252_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_hand_tracking_microgestures" number="253" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_EXT_hand_interaction"> + <require> + <enum value="1" name="XR_META_hand_tracking_microgestures_SPEC_VERSION"/> + <enum value=""XR_META_hand_tracking_microgestures"" name="XR_META_HAND_TRACKING_MICROGESTURES_EXTENSION_NAME"/> + + <extend interaction_profile_path="/interaction_profiles/ext/hand_interaction_ext"> + <component subpath="/input/swipe_left_meta/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/swipe_right_meta/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/swipe_forward_meta/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/swipe_backward_meta/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/tap_thumb_meta/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_FB_extension_254" number="254" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_254_SPEC_VERSION"/> + <enum value=""XR_FB_extension_254"" name="XR_FB_EXTENSION_254_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_recommended_layer_resolution" number="255" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_recommended_layer_resolution_SPEC_VERSION"/> + <enum value=""XR_META_recommended_layer_resolution"" name="XR_META_RECOMMENDED_LAYER_RESOLUTION_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_RECOMMENDED_LAYER_RESOLUTION_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_RECOMMENDED_LAYER_RESOLUTION_GET_INFO_META"/> + + <type name="XrRecommendedLayerResolutionMETA"/> + <type name="XrRecommendedLayerResolutionGetInfoMETA"/> + + <command name="xrGetRecommendedLayerResolutionMETA"/> + </require> + </extension> + + <extension name="XR_FB_extension_256" number="256" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_256_SPEC_VERSION"/> + <enum value=""XR_FB_extension_256"" name="XR_FB_EXTENSION_256_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_257" number="257" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_257_SPEC_VERSION"/> + <enum value=""XR_FB_extension_257"" name="XR_FB_EXTENSION_257_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_258" number="258" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_258_SPEC_VERSION"/> + <enum value=""XR_FB_extension_258"" name="XR_FB_EXTENSION_258_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_259" number="259" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_259_SPEC_VERSION"/> + <enum value=""XR_FB_extension_259"" name="XR_FB_EXTENSION_259_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_spatial_entity_persistence" number="260" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_spatial_entity_persistence_SPEC_VERSION"/> + <enum value=""XR_META_spatial_entity_persistence"" name="XR_META_SPATIAL_ENTITY_PERSISTENCE_EXTENSION_NAME"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SPACE_INSUFFICIENT_RESOURCES_META" comment="Resource limitation prevented this operation from executing. Recommend retrying, perhaps after a short delay and/or reducing memory consumption."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPACE_STORAGE_AT_CAPACITY_META" comment="Operation could not be completed until resources used are reduced or storage expanded."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_SPACE_INSUFFICIENT_VIEW_META" comment="Look around the environment more for space tracking to function."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_SPACE_PERMISSION_INSUFFICIENT_META" comment="Space operation permission insufficient. Recommend confirming the status of the required permissions needed for using Space APIs."/> + <enum offset="4" dir="-" extends="XrResult" name="XR_ERROR_SPACE_RATE_LIMITED_META" comment="Operation cancelled due to rate limiting. Recommend retrying after a short delay."/> + <enum offset="5" dir="-" extends="XrResult" name="XR_ERROR_SPACE_TOO_DARK_META" comment="Environment too dark for tracking to complete operation."/> + <enum offset="6" dir="-" extends="XrResult" name="XR_ERROR_SPACE_TOO_BRIGHT_META" comment="Environment too bright for tracking to complete operation."/> + + <type name="XrSystemSpacePersistencePropertiesMETA"/> + <type name="XrSpacesSaveInfoMETA"/> + <type name="XrEventDataSpacesSaveResultMETA"/> + <type name="XrSpacesEraseInfoMETA"/> + <type name="XrEventDataSpacesEraseResultMETA"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPACE_PERSISTENCE_PROPERTIES_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPACES_SAVE_INFO_META"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPACES_SAVE_RESULT_META"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPACES_ERASE_INFO_META"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPACES_ERASE_RESULT_META"/> + + <command name="xrSaveSpacesMETA"/> + <command name="xrEraseSpacesMETA"/> + </require> + </extension> + + <extension name="XR_FB_extension_261" number="261" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_261_SPEC_VERSION"/> + <enum value=""XR_FB_extension_261"" name="XR_FB_EXTENSION_261_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_262" number="262" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_262_SPEC_VERSION"/> + <enum value=""XR_FB_extension_262"" name="XR_FB_EXTENSION_262_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_263" number="263" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_263_SPEC_VERSION"/> + <enum value=""XR_FB_extension_263"" name="XR_FB_EXTENSION_263_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_264" number="264" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_264_SPEC_VERSION"/> + <enum value=""XR_FB_extension_264"" name="XR_FB_EXTENSION_264_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_265" number="265" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_265_SPEC_VERSION"/> + <enum value=""XR_FB_extension_265"" name="XR_FB_EXTENSION_265_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_266" number="266" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_266_SPEC_VERSION"/> + <enum value=""XR_FB_extension_266"" name="XR_FB_EXTENSION_266_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_passthrough_color_lut" number="267" type="instance" depends="XR_VERSION_1_0+XR_FB_passthrough" supported="openxr"> + <require> + <enum value="1" name="XR_META_passthrough_color_lut_SPEC_VERSION"/> + <enum value=""XR_META_passthrough_color_lut"" name="XR_META_PASSTHROUGH_COLOR_LUT_EXTENSION_NAME"/> + + <type name="XrPassthroughColorLutMETA"/> + <type name="XrPassthroughColorLutChannelsMETA"/> + <type name="XrPassthroughColorLutDataMETA"/> + <type name="XrPassthroughColorLutCreateInfoMETA"/> + <type name="XrPassthroughColorLutUpdateInfoMETA"/> + <type name="XrPassthroughColorMapLutMETA"/> + <type name="XrPassthroughColorMapInterpolatedLutMETA"/> + <type name="XrSystemPassthroughColorLutPropertiesMETA"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_PASSTHROUGH_COLOR_LUT_PROPERTIES_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_COLOR_LUT_CREATE_INFO_META"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_COLOR_LUT_UPDATE_INFO_META"/> + <enum offset="100" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_COLOR_MAP_LUT_META"/> + <enum offset="101" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_COLOR_MAP_INTERPOLATED_LUT_META"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_PASSTHROUGH_COLOR_LUT_META" comment="XrPassthroughColorLutMETA"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_PASSTHROUGH_COLOR_LUT_BUFFER_SIZE_MISMATCH_META" comment="The provided data buffer did not match the required size."/> + + <command name="xrCreatePassthroughColorLutMETA"/> + <command name="xrDestroyPassthroughColorLutMETA"/> + <command name="xrUpdatePassthroughColorLutMETA"/> + </require> + </extension> + + <extension name="XR_FB_extension_268" number="268" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_268_SPEC_VERSION"/> + <enum value=""XR_FB_extension_268"" name="XR_FB_EXTENSION_268_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_269" number="269" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_269_SPEC_VERSION"/> + <enum value=""XR_FB_extension_269"" name="XR_FB_EXTENSION_269_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_spatial_entity_mesh" number="270" type="instance" depends="XR_VERSION_1_0+XR_FB_spatial_entity" supported="openxr"> + <require> + <enum value="1" name="XR_META_spatial_entity_mesh_SPEC_VERSION"/> + <enum value=""XR_META_spatial_entity_mesh"" name="XR_META_SPATIAL_ENTITY_MESH_EXTENSION_NAME"/> + + <enum offset="0" extends="XrSpaceComponentTypeFB" name="XR_SPACE_COMPONENT_TYPE_TRIANGLE_MESH_META" comment="Triangle mesh component."/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPACE_TRIANGLE_MESH_GET_INFO_META"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPACE_TRIANGLE_MESH_META"/> + + <type name="XrSpaceTriangleMeshGetInfoMETA"/> + <type name="XrSpaceTriangleMeshMETA"/> + + <command name="xrGetSpaceTriangleMeshMETA"/> + </require> + </extension> + + <extension name="XR_FB_extension_271" number="271" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_271_SPEC_VERSION"/> + <enum value=""XR_FB_extension_271"" name="XR_FB_EXTENSION_271_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_automatic_layer_filter" number="272" type="instance" depends="XR_VERSION_1_0+XR_FB_composition_layer_settings" supported="openxr"> + <require> + <enum value="1" name="XR_META_automatic_layer_filter_SPEC_VERSION"/> + <enum value=""XR_META_automatic_layer_filter"" name="XR_META_AUTOMATIC_LAYER_FILTER_EXTENSION_NAME"/> + <enum bitpos="5" extends="XrCompositionLayerSettingsFlagBitsFB" name="XR_COMPOSITION_LAYER_SETTINGS_AUTO_LAYER_FILTER_BIT_META" comment="Indicates compositor may: automatically toggle a texture filtering mechanism to improve visual quality of layer. This must: not be the only bit set. (Added by apiext:XR_META_automatic_layer_filter)"/> + </require> + </extension> + + <extension name="XR_FB_extension_273" number="273" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_273_SPEC_VERSION"/> + <enum value=""XR_FB_extension_273"" name="XR_FB_EXTENSION_273_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_274" number="274" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_274_SPEC_VERSION"/> + <enum value=""XR_FB_extension_274"" name="XR_FB_EXTENSION_274_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_body_tracking_full_body" number="275" type="instance" supported="openxr" depends="XR_FB_body_tracking"> + <require> + <enum value="1" name="XR_META_body_tracking_full_body_SPEC_VERSION"/> + <enum value=""XR_META_body_tracking_full_body"" name="XR_META_BODY_TRACKING_FULL_BODY_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_FULL_BODY_META"/> + <enum offset="0" extends="XrBodyJointSetFB" name="XR_BODY_JOINT_SET_FULL_BODY_META" comment="Indicates that the created slink:XrBodyTrackerFB tracks the set of body joints described by elink:XrFullBodyJointMETA enum, i.e. the flink:xrLocateBodyJointsFB function returns an array of joint locations with the count of ename:XR_FULL_BODY_JOINT_COUNT_META and can be indexed using elink:XrFullBodyJointMETA. This extends the joints of ename:XR_BODY_JOINT_SET_DEFAULT_FB by also including the lower body."/> + + <type name="XrFullBodyJointMETA"/> + <type name="XrSystemPropertiesBodyTrackingFullBodyMETA"/> + </require> + </extension> + + <extension name="XR_FB_extension_276" number="276" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_276_SPEC_VERSION"/> + <enum value=""XR_FB_extension_276"" name="XR_FB_EXTENSION_276_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_277" number="277" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_277_SPEC_VERSION"/> + <enum value=""XR_FB_extension_277"" name="XR_FB_EXTENSION_277_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_278" number="278" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_278_SPEC_VERSION"/> + <enum value=""XR_FB_extension_278"" name="XR_FB_EXTENSION_278_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_279" number="279" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_279_SPEC_VERSION"/> + <enum value=""XR_FB_extension_279"" name="XR_FB_EXTENSION_279_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_touch_controller_plus" number="280" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="1" name="XR_META_touch_controller_plus_SPEC_VERSION"/> + <enum value=""XR_META_touch_controller_plus"" name="XR_META_TOUCH_CONTROLLER_PLUS_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/meta/touch_controller_plus"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_plus"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_plus"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_plus"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_FB_extension_281" number="281" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_281_SPEC_VERSION"/> + <enum value=""XR_FB_extension_281"" name="XR_FB_EXTENSION_281_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_282" number="282" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_282_SPEC_VERSION"/> + <enum value=""XR_FB_extension_282"" name="XR_FB_EXTENSION_282_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_passthrough_layer_resumed_event" number="283" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_FB_passthrough"> + <require> + <enum value="1" name="XR_META_passthrough_layer_resumed_event_SPEC_VERSION"/> + <enum value=""XR_META_passthrough_layer_resumed_event"" name="XR_META_PASSTHROUGH_LAYER_RESUMED_EVENT_EXTENSION_NAME"/> + + <type name="XrEventDataPassthroughLayerResumedMETA"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_PASSTHROUGH_LAYER_RESUMED_META"/> + </require> + </extension> + + <extension name="XR_META_body_tracking_calibration" number="284" type="instance" supported="openxr" depends="XR_FB_body_tracking"> + <require> + <enum value="1" name="XR_META_body_tracking_calibration_SPEC_VERSION"/> + <enum value=""XR_META_body_tracking_calibration"" name="XR_META_BODY_TRACKING_CALIBRATION_EXTENSION_NAME"/> + + <enum offset="2" extends="XrStructureType" name="XR_TYPE_BODY_TRACKING_CALIBRATION_INFO_META"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_BODY_TRACKING_CALIBRATION_STATUS_META"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_CALIBRATION_META"/> + <command name="xrSuggestBodyTrackingCalibrationOverrideMETA"/> + <command name="xrResetBodyTrackingCalibrationMETA"/> + + <type name="XrBodyTrackingCalibrationStatusMETA"/> + <type name="XrBodyTrackingCalibrationStateMETA"/> + <type name="XrBodyTrackingCalibrationInfoMETA"/> + <type name="XrSystemPropertiesBodyTrackingCalibrationMETA"/> + </require> + </extension> + + <extension name="XR_META_body_tracking_fidelity" number="285" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_FB_body_tracking"> + <require> + <enum value="1" name="XR_META_body_tracking_fidelity_SPEC_VERSION"/> + <enum value=""XR_META_body_tracking_fidelity"" name="XR_META_BODY_TRACKING_FIDELITY_EXTENSION_NAME"/> + + <command name="xrRequestBodyTrackingFidelityMETA"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_BODY_TRACKING_FIDELITY_STATUS_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_FIDELITY_META"/> + + <type name="XrSystemPropertiesBodyTrackingFidelityMETA"/> + <type name="XrBodyTrackingFidelityMETA"/> + <type name="XrBodyTrackingFidelityStatusMETA"/> + </require> + </extension> + + <extension name="XR_FB_extension_286" number="286" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_286_SPEC_VERSION"/> + <enum value=""XR_FB_extension_286"" name="XR_FB_EXTENSION_286_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_287" number="287" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_287_SPEC_VERSION"/> + <enum value=""XR_FB_extension_287"" name="XR_FB_EXTENSION_287_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_face_tracking2" number="288" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_face_tracking2_SPEC_VERSION"/> + <enum value=""XR_FB_face_tracking2"" name="XR_FB_FACE_TRACKING2_EXTENSION_NAME"/> + + <enum offset="12" extends="XrObjectType" name="XR_OBJECT_TYPE_FACE_TRACKER2_FB" comment="XrFaceTracker2FB"/> + <type name="XrFaceTracker2FB"/> + + <type name="XrFaceExpression2FB"/> + <type name="XrFaceExpressionSet2FB"/> + <type name="XrFaceTrackingDataSource2FB"/> + <type name="XrFaceConfidence2FB"/> + + <enum offset="13" extends="XrStructureType" name="XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES2_FB"/> + <type name="XrSystemFaceTrackingProperties2FB"/> + + <enum offset="14" extends="XrStructureType" name="XR_TYPE_FACE_TRACKER_CREATE_INFO2_FB"/> + <type name="XrFaceTrackerCreateInfo2FB"/> + + <enum offset="15" extends="XrStructureType" name="XR_TYPE_FACE_EXPRESSION_INFO2_FB"/> + <type name="XrFaceExpressionInfo2FB"/> + + <enum offset="16" extends="XrStructureType" name="XR_TYPE_FACE_EXPRESSION_WEIGHTS2_FB"/> + <type name="XrFaceExpressionWeights2FB"/> + + <command name="xrCreateFaceTracker2FB"/> + <command name="xrDestroyFaceTracker2FB"/> + <command name="xrGetFaceExpressionWeights2FB"/> + </require> + </extension> + + <extension name="XR_FB_extension_289" number="289" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_289_SPEC_VERSION"/> + <enum value=""XR_FB_extension_289"" name="XR_FB_EXTENSION_289_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_290" number="290" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_290_SPEC_VERSION"/> + <enum value=""XR_FB_extension_290"" name="XR_FB_EXTENSION_290_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_spatial_entity_sharing" number="291" type="instance" supported="openxr" depends="XR_FB_spatial_entity"> + <require> + <enum value="1" name="XR_META_spatial_entity_sharing_SPEC_VERSION"/> + <enum value=""XR_META_spatial_entity_sharing"" name="XR_META_SPATIAL_ENTITY_SHARING_EXTENSION_NAME"/> + + <enum value="32" name="XR_MAX_SPACES_PER_SHARE_REQUEST_META"/> + + <type name="XrSystemSpatialEntitySharingPropertiesMETA"/> + + <type name="XrShareSpacesRecipientBaseHeaderMETA"/> + <type name="XrShareSpacesInfoMETA"/> + <type name="XrEventDataShareSpacesCompleteMETA"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPATIAL_ENTITY_SHARING_PROPERTIES_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SHARE_SPACES_INFO_META"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SHARE_SPACES_COMPLETE_META"/> + + <command name="xrShareSpacesMETA"/> + </require> + </extension> + + + <extension name="XR_META_environment_depth" number="292" type="instance" supported="openxr"> + <require> + <enum value="2" name="XR_META_environment_depth_SPEC_VERSION"/> + <enum value=""XR_META_environment_depth"" name="XR_META_ENVIRONMENT_DEPTH_EXTENSION_NAME"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_ENVIRONMENT_DEPTH_PROVIDER_META" comment="XrEnvironmentDepthProviderMETA"/> + <enum offset="1" extends="XrObjectType" name="XR_OBJECT_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_META" comment="XrEnvironmentDepthSwapchainMETA"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_DEPTH_PROVIDER_CREATE_INFO_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_CREATE_INFO_META"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_STATE_META"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_ACQUIRE_INFO_META"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_VIEW_META"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_META"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_DEPTH_HAND_REMOVAL_SET_INFO_META"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_SYSTEM_ENVIRONMENT_DEPTH_PROPERTIES_META"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_TIMESTAMP_META"/> + + <!-- Successful return codes. --> + <enum offset="0" extends="XrResult" name="XR_ENVIRONMENT_DEPTH_NOT_AVAILABLE_META" comment="Warning: The requested depth image is not yet available."/> + + <type name="XrEnvironmentDepthProviderMETA"/> + <type name="XrEnvironmentDepthSwapchainMETA"/> + <type name="XrEnvironmentDepthProviderCreateInfoMETA"/> + <type name="XrEnvironmentDepthProviderCreateFlagsMETA"/> + <type name="XrEnvironmentDepthProviderCreateFlagBitsMETA"/> + <type name="XrEnvironmentDepthSwapchainCreateFlagsMETA"/> + <type name="XrEnvironmentDepthSwapchainCreateFlagBitsMETA"/> + <type name="XrEnvironmentDepthSwapchainCreateInfoMETA"/> + <type name="XrEnvironmentDepthSwapchainStateMETA"/> + <type name="XrEnvironmentDepthImageAcquireInfoMETA"/> + <type name="XrEnvironmentDepthImageViewMETA"/> + <type name="XrEnvironmentDepthImageMETA"/> + <type name="XrEnvironmentDepthImageTimestampMETA"/> + <type name="XrEnvironmentDepthHandRemovalSetInfoMETA"/> + <type name="XrSystemEnvironmentDepthPropertiesMETA"/> + + <command name="xrCreateEnvironmentDepthProviderMETA"/> + <command name="xrDestroyEnvironmentDepthProviderMETA"/> + <command name="xrStartEnvironmentDepthProviderMETA"/> + <command name="xrStopEnvironmentDepthProviderMETA"/> + <command name="xrCreateEnvironmentDepthSwapchainMETA"/> + <command name="xrDestroyEnvironmentDepthSwapchainMETA"/> + <command name="xrEnumerateEnvironmentDepthSwapchainImagesMETA"/> + <command name="xrGetEnvironmentDepthSwapchainStateMETA"/> + <command name="xrAcquireEnvironmentDepthImageMETA"/> + <command name="xrSetEnvironmentDepthHandRemovalMETA"/> </require> + </extension> + + <extension name="XR_FB_extension_293" number="293" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_293_SPEC_VERSION"/> + <enum value=""XR_FB_extension_293"" name="XR_FB_EXTENSION_293_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_294" number="294" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_294_SPEC_VERSION"/> + <enum value=""XR_FB_extension_294"" name="XR_FB_EXTENSION_294_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_295" number="295" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_295_SPEC_VERSION"/> + <enum value=""XR_FB_extension_295"" name="XR_FB_EXTENSION_295_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_296" number="296" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_296_SPEC_VERSION"/> + <enum value=""XR_FB_extension_296"" name="XR_FB_EXTENSION_296_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_297" number="297" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_297_SPEC_VERSION"/> + <enum value=""XR_FB_extension_297"" name="XR_FB_EXTENSION_297_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_298" number="298" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_298_SPEC_VERSION"/> + <enum value=""XR_FB_extension_298"" name="XR_FB_EXTENSION_298_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_299" number="299" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_299_SPEC_VERSION"/> + <enum value=""XR_FB_extension_299"" name="XR_FB_EXTENSION_299_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_uuid" number="300" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="1" name="XR_EXT_uuid_SPEC_VERSION"/> + <enum value=""XR_EXT_uuid"" name="XR_EXT_UUID_EXTENSION_NAME"/> + <type name="XrUuidEXT"/> + <enum value="16" name="XR_UUID_SIZE_EXT"/> + </require> + </extension> + + <extension name="XR_EXT_render_model" number="301" type="instance" supported="openxr" depends="XR_VERSION_1_1,XR_EXT_uuid" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_render_model_SPEC_VERSION"/> + <enum value=""XR_EXT_render_model"" name="XR_EXT_RENDER_MODEL_EXTENSION_NAME"/> + + <type name="XrRenderModelIdEXT"/> + + <type name="XrRenderModelEXT"/> + <type name="XrRenderModelCreateInfoEXT"/> + <type name="XrRenderModelPropertiesGetInfoEXT"/> + <type name="XrRenderModelPropertiesEXT"/> + <type name="XrRenderModelSpaceCreateInfoEXT"/> + <type name="XrRenderModelStateGetInfoEXT"/> + <type name="XrRenderModelNodeStateEXT"/> + <type name="XrRenderModelStateEXT"/> + + <type name="XrRenderModelAssetEXT"/> + <type name="XrRenderModelAssetCreateInfoEXT"/> + <type name="XrRenderModelAssetDataGetInfoEXT"/> + <type name="XrRenderModelAssetDataEXT"/> + <type name="XrRenderModelAssetPropertiesGetInfoEXT"/> + <type name="XrRenderModelAssetNodePropertiesEXT"/> + <type name="XrRenderModelAssetPropertiesEXT"/> + + <command name="xrCreateRenderModelEXT"/> + <command name="xrDestroyRenderModelEXT"/> + <command name="xrGetRenderModelPropertiesEXT"/> + <command name="xrCreateRenderModelSpaceEXT"/> + <command name="xrCreateRenderModelAssetEXT"/> + <command name="xrDestroyRenderModelAssetEXT"/> + <command name="xrGetRenderModelAssetDataEXT"/> + <command name="xrGetRenderModelAssetPropertiesEXT"/> + <command name="xrGetRenderModelStateEXT"/> + + <enum value="0" name="XR_NULL_RENDER_MODEL_ID_EXT"/> + <enum value="64" name="XR_MAX_RENDER_MODEL_ASSET_NODE_NAME_SIZE_EXT"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_RENDER_MODEL_EXT" comment="XrRenderModelEXT"/> + <enum offset="1" extends="XrObjectType" name="XR_OBJECT_TYPE_RENDER_MODEL_ASSET_EXT" comment="XrRenderModelAssetEXT"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_CREATE_INFO_EXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_PROPERTIES_GET_INFO_EXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_PROPERTIES_EXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_SPACE_CREATE_INFO_EXT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_STATE_GET_INFO_EXT"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_STATE_EXT"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_ASSET_CREATE_INFO_EXT"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_ASSET_DATA_GET_INFO_EXT"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_ASSET_DATA_EXT"/> + <enum offset="9" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_ASSET_PROPERTIES_GET_INFO_EXT"/> + <enum offset="10" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_ASSET_PROPERTIES_EXT"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_RENDER_MODEL_ID_INVALID_EXT" comment="The render model ID is invalid."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_RENDER_MODEL_ASSET_UNAVAILABLE_EXT" comment="The render model asset is unavailable."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_RENDER_MODEL_GLTF_EXTENSION_REQUIRED_EXT" comment="A glTF extension is required."/> + </require> + </extension> + + <extension name="XR_EXT_interaction_render_model" number="302" type="instance" supported="openxr" depends="XR_EXT_render_model" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_interaction_render_model_SPEC_VERSION"/> + <enum value=""XR_EXT_interaction_render_model"" name="XR_EXT_INTERACTION_RENDER_MODEL_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_INTERACTION_RENDER_MODEL_IDS_ENUMERATE_INFO_EXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_INTERACTION_RENDER_MODEL_SUBACTION_PATH_INFO_EXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_INTERACTION_RENDER_MODELS_CHANGED_EXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_INTERACTION_RENDER_MODEL_TOP_LEVEL_USER_PATH_GET_INFO_EXT"/> + + <type name="XrInteractionRenderModelIdsEnumerateInfoEXT"/> + <type name="XrInteractionRenderModelSubactionPathInfoEXT"/> + <type name="XrInteractionRenderModelTopLevelUserPathGetInfoEXT"/> + <type name="XrEventDataInteractionRenderModelsChangedEXT"/> + <command name="xrEnumerateInteractionRenderModelIdsEXT"/> + <command name="xrEnumerateRenderModelSubactionPathsEXT"/> + <command name="xrGetRenderModelPoseTopLevelUserPathEXT"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_NOT_INTERACTION_RENDER_MODEL_EXT" comment="The provided slink:XrRenderModelEXT was not created from a basetype:XrRenderModelIdEXT from `<<XR_EXT_interaction_render_model>>`"/> + </require> + </extension> + + <extension name="XR_EXT_hand_interaction" number="303" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="2" name="XR_EXT_hand_interaction_SPEC_VERSION"/> + <enum value=""XR_EXT_hand_interaction"" name="XR_EXT_HAND_INTERACTION_EXTENSION_NAME"/> + + <interaction_profile name="/interaction_profiles/ext/hand_interaction_ext"/> + + <!-- + Only core 1.0 interaction profiles get extended here. + Others get this pose added in a nested <require depends="XR_EXT_hand_interaction"> + inside the extension and/or feature that adds them. + --> + <extend interaction_profile_path="/interaction_profiles/khr/simple_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/google/daydream_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/htc/vive_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/microsoft/motion_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/oculus/go_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/oculus/touch_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/valve/index_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/ext/hand_interaction_ext"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_QCOM_image_tracking" number="304" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_image_tracking_SPEC_VERSION"/> + <enum value=""XR_QCOM_image_tracking"" name="XR_QCOM_IMAGE_TRACKING_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_object_tracking" number="305" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_object_tracking_SPEC_VERSION"/> + <enum value=""XR_QCOM_object_tracking"" name="XR_QCOM_OBJECT_TRACKING_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_plane_detection" number="306" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_plane_detection_SPEC_VERSION"/> + <enum value=""XR_QCOM_plane_detection"" name="XR_QCOM_PLANE_DETECTION_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_tracking_optimization_settings" number="307" type="instance" supported="openxr"> + <require> + <enum value="2" name="XR_QCOM_tracking_optimization_settings_SPEC_VERSION"/> + <enum value=""XR_QCOM_tracking_optimization_settings"" name="XR_QCOM_TRACKING_OPTIMIZATION_SETTINGS_EXTENSION_NAME"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_HINT_ALREADY_SET_QCOM" comment="Tracking optimization hint is already set for the domain."/> + + <type name="XrTrackingOptimizationSettingsDomainQCOM"/> + <type name="XrTrackingOptimizationSettingsHintQCOM"/> + + <enum extends="XrTrackingOptimizationSettingsHintQCOM" name="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LONG_RANGE_PRIORIZATION_QCOM" alias="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LONG_RANGE_PRIORITIZATION_QCOM" comment="Backward-compatibility alias containing typo."/> + <enum extends="XrTrackingOptimizationSettingsHintQCOM" name="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_CLOSE_RANGE_PRIORIZATION_QCOM" alias="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_CLOSE_RANGE_PRIORITIZATION_QCOM" comment="Backward-compatibility alias containing typo."/> + <enum extends="XrTrackingOptimizationSettingsHintQCOM" name="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LOW_POWER_PRIORIZATION_QCOM" alias="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LOW_POWER_PRIORITIZATION_QCOM" comment="Backward-compatibility alias containing typo."/> + <enum extends="XrTrackingOptimizationSettingsHintQCOM" name="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_HIGH_POWER_PRIORIZATION_QCOM" alias="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_HIGH_POWER_PRIORITIZATION_QCOM" comment="Backward-compatibility alias containing typo."/> + + <command name="xrSetTrackingOptimizationSettingsHintQCOM"/> + </require> + </extension> + + <extension name="XR_QCOM_ray_casting" number="308" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_ray_casting_SPEC_VERSION"/> + <enum value=""XR_QCOM_ray_casting"" name="XR_QCOM_RAY_CASTING_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_309" number="309" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_309_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_309"" name="XR_QCOM_EXTENSION_309_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_310" number="310" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_310_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_310"" name="XR_QCOM_EXTENSION_310_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_hand_tracking_gesture" number="311" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_EXT_hand_tracking" deprecatedby="XR_EXT_hand_interaction"> + <require> + <enum value="1" name="XR_QCOM_hand_tracking_gesture_SPEC_VERSION"/> + <enum value=""XR_QCOM_hand_tracking_gesture"" name="XR_QCOM_HAND_TRACKING_GESTURE_EXTENSION_NAME"/> + + <type name="XrHandGestureTypeQCOM"/> + <type name="XrHandGestureQCOM"/> + + <command name="xrGetHandGestureQCOM"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_312" number="312" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_312_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_312"" name="XR_QCOM_EXTENSION_312_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_313" number="313" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_313_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_313"" name="XR_QCOM_EXTENSION_313_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_314" number="314" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_314_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_314"" name="XR_QCOM_EXTENSION_314_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_315" number="315" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_315_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_315"" name="XR_QCOM_EXTENSION_315_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_316" number="316" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_316_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_316"" name="XR_QCOM_EXTENSION_316_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_317" number="317" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_317_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_317"" name="XR_QCOM_EXTENSION_317_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_passthrough" number="318" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_HTC_passthrough_SPEC_VERSION"/> + <enum value=""XR_HTC_passthrough"" name="XR_HTC_PASSTHROUGH_EXTENSION_NAME"/> + + <type name="XrPassthroughHTC"/> + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_PASSTHROUGH_HTC" comment="XrPassthroughHTC"/> + + <type name="XrPassthroughFormHTC"/> + + <type name="XrPassthroughCreateInfoHTC"/> + <type name="XrPassthroughColorHTC"/> + <type name="XrPassthroughMeshTransformInfoHTC"/> + <type name="XrCompositionLayerPassthroughHTC"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_CREATE_INFO_HTC"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_COLOR_HTC"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_MESH_TRANSFORM_INFO_HTC"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_HTC"/> + + <command name="xrCreatePassthroughHTC"/> + <command name="xrDestroyPassthroughHTC"/> + </require> + </extension> + + <extension name="XR_HTC_foveation" number="319" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_HTC_foveation_SPEC_VERSION"/> + <enum value=""XR_HTC_foveation"" name="XR_HTC_FOVEATION_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_FOVEATION_APPLY_INFO_HTC"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_FOVEATION_DYNAMIC_MODE_INFO_HTC"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_FOVEATION_CUSTOM_MODE_INFO_HTC"/> + + <type name="XrFoveationModeHTC"/> + <type name="XrFoveationLevelHTC"/> + + <type name="XrFoveationApplyInfoHTC"/> + <type name="XrFoveationConfigurationHTC"/> + <type name="XrFoveationDynamicModeInfoHTC"/> + <type name="XrFoveationCustomModeInfoHTC"/> + <type name="XrFoveationDynamicFlagsHTC"/> + <type name="XrFoveationDynamicFlagBitsHTC"/> + + <command name="xrApplyFoveationHTC"/> + </require> + </extension> + + <extension name="XR_HTC_anchor" number="320" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_HTC_anchor_SPEC_VERSION"/> + <enum value=""XR_HTC_anchor"" name="XR_HTC_ANCHOR_EXTENSION_NAME"/> + <enum value="256" name="XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_HTC"/> + <type name="XrSystemAnchorPropertiesHTC"/> + <type name="XrSpatialAnchorCreateInfoHTC"/> + <type name="XrSpatialAnchorNameHTC"/> + <command name="xrCreateSpatialAnchorHTC"/> + <command name="xrGetSpatialAnchorNameHTC"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_ANCHOR_PROPERTIES_HTC"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_HTC"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_NOT_AN_ANCHOR_HTC" comment="The provided space is valid but not an anchor."/> + </require> + </extension> + + <extension name="XR_HTC_body_tracking" number="321" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_HTC_body_tracking_SPEC_VERSION"/> + <enum value=""XR_HTC_body_tracking"" name="XR_HTC_BODY_TRACKING_EXTENSION_NAME"/> + + <command name="xrCreateBodyTrackerHTC"/> + <command name="xrDestroyBodyTrackerHTC"/> + <command name="xrLocateBodyJointsHTC"/> + <command name="xrGetBodySkeletonHTC"/> + + <type name="XrBodyJointHTC"/> + <type name="XrBodyJointSetHTC"/> + <type name="XrBodyJointConfidenceHTC"/> + + <type name="XrBodyTrackerHTC"/> + <type name="XrSystemBodyTrackingPropertiesHTC"/> + <type name="XrBodyTrackerCreateInfoHTC"/> + <type name="XrBodyJointsLocateInfoHTC"/> + <type name="XrBodyJointLocationsHTC"/> + <type name="XrBodyJointLocationHTC"/> + <type name="XrBodySkeletonHTC"/> + <type name="XrBodySkeletonJointHTC"/> + + <type name="XR_BODY_JOINT_COUNT_HTC"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_BODY_TRACKER_HTC" comment="XrBodyTrackerHTC"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_HTC"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_BODY_TRACKER_CREATE_INFO_HTC"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_BODY_JOINTS_LOCATE_INFO_HTC"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_BODY_JOINT_LOCATIONS_HTC"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_BODY_SKELETON_HTC"/> + </require> + </extension> + + <extension name="XR_HTC_extension_322" number="322" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_322_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_322"" name="XR_HTC_extension_322_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_323" number="323" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_323_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_323"" name="XR_HTC_extension_323_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_324" number="324" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_324_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_324"" name="XR_HTC_extension_324_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_325" number="325" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_325_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_325"" name="XR_HTC_extension_325_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_326" number="326" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_326_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_326"" name="XR_HTC_extension_326_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_327" number="327" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_327_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_327"" name="XR_HTC_extension_327_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_328" number="328" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_328_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_328"" name="XR_HTC_extension_328_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_329" number="329" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_329_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_329"" name="XR_HTC_extension_329_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_330" number="330" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_330_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_330"" name="XR_HTC_extension_330_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_331" number="331" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_331_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_331"" name="XR_HTC_extension_331_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_332" number="332" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_332_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_332"" name="XR_HTC_extension_332_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_333" number="333" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_333_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_333"" name="XR_HTC_extension_333_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_334" number="334" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_334_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_334"" name="XR_HTC_extension_334_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_335" number="335" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_335_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_335"" name="XR_HTC_extension_335_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_336" number="336" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_336_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_336"" name="XR_HTC_extension_336_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_337" number="337" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_337_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_337"" name="XR_HTC_extension_337_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_338" number="338" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_338_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_338"" name="XR_HTC_extension_338_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_339" number="339" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_339_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_339"" name="XR_HTC_extension_339_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_340" number="340" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_340_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_340"" name="XR_HTC_extension_340_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_341" number="341" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_341_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_341"" name="XR_HTC_extension_341_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_342" number="342" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_342_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_342"" name="XR_HTC_extension_342_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_343" number="343" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_343_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_343"" name="XR_HTC_extension_343_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_344" number="344" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_344_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_344"" name="XR_HTC_extension_344_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_345" number="345" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_345_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_345"" name="XR_HTC_extension_345_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_346" number="346" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_346_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_346"" name="XR_HTC_extension_346_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_347" number="347" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_347_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_347"" name="XR_HTC_extension_347_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_348" number="348" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_348_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_348"" name="XR_HTC_extension_348_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_349" number="349" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_349_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_349"" name="XR_HTC_extension_349_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_350" number="350" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_350_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_350"" name="XR_HTC_extension_350_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_351" number="351" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_351_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_351"" name="XR_HTC_extension_351_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_352" number="352" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_352_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_352"" name="XR_HTC_extension_352_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_353" number="353" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_353_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_353"" name="XR_HTC_extension_353_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_354" number="354" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_354_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_354"" name="XR_HTC_extension_354_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_355" number="355" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_355_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_355"" name="XR_HTC_extension_355_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_356" number="356" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_356_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_356"" name="XR_HTC_extension_356_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_357" number="357" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_357_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_357"" name="XR_HTC_extension_357_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_358" number="358" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_358_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_358"" name="XR_HTC_extension_358_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_359" number="359" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_359_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_359"" name="XR_HTC_extension_359_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_360" number="360" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_360_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_360"" name="XR_HTC_extension_360_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_361" number="361" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_361_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_361"" name="XR_HTC_extension_361_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_362" number="362" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_362_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_362"" name="XR_HTC_extension_362_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_363" number="363" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_363_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_363"" name="XR_HTC_extension_363_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_364" number="364" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_364_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_364"" name="XR_HTC_extension_364_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_365" number="365" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_365_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_365"" name="XR_HTC_extension_365_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_366" number="366" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_366_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_366"" name="XR_HTC_extension_366_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_367" number="367" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_367_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_367"" name="XR_HTC_extension_367_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_368" number="368" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_368_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_368"" name="XR_HTC_extension_368_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_369" number="369" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_369_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_369"" name="XR_HTC_extension_369_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_370" number="370" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_370_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_370"" name="XR_HTC_extension_370_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_371" number="371" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_371_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_371"" name="XR_EXT_extension_371_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_372" number="372" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_372_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_372"" name="XR_EXT_extension_372_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_KHR_extendable_action_binding" number="373" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_KHR_extendable_action_binding_SPEC_VERSION"/> + <enum value=""XR_KHR_extendable_action_binding"" name="XR_KHR_EXTENDABLE_ACTION_BINDING_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_active_action_set_priority" number="374" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_EXT_active_action_set_priority_SPEC_VERSION"/> + <enum value=""XR_EXT_active_action_set_priority"" name="XR_EXT_ACTIVE_ACTION_SET_PRIORITY_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_ACTIVE_ACTION_SET_PRIORITIES_EXT"/> + <type name="XrActiveActionSetPrioritiesEXT"/> + <type name="XrActiveActionSetPriorityEXT"/> + </require> + </extension> + + <extension name="XR_HUAWEI_6dof_controller_interaction" number="375" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HUAWEI_6dof_controller_interaction_SPEC_VERSION"/> + <enum value=""XR_HUAWEI_6dof_controller_interaction"" name="XR_HUAWEI_6DOF_CONTROLLER_INTERACTION_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MNDX_force_feedback_curl" number="376" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_EXT_hand_tracking" provisional="true"> + <require> + <enum value="1" name="XR_MNDX_force_feedback_curl_SPEC_VERSION"/> + <enum value=""XR_MNDX_force_feedback_curl"" name="XR_MNDX_FORCE_FEEDBACK_CURL_EXTENSION_NAME"/> + + <command name="xrApplyForceFeedbackCurlMNDX"/> + + <type name="XrSystemForceFeedbackCurlPropertiesMNDX"/> + <type name="XrForceFeedbackCurlLocationMNDX"/> + <type name="XrForceFeedbackCurlApplyLocationsMNDX"/> + <type name="XrForceFeedbackCurlApplyLocationMNDX"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_FORCE_FEEDBACK_CURL_PROPERTIES_MNDX"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_FORCE_FEEDBACK_CURL_APPLY_LOCATIONS_MNDX"/> + </require> + </extension> + + <extension name="XR_MND_extension_377" number="377" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_377_SPEC_VERSION"/> + <enum value=""XR_MND_extension_377"" name="XR_MND_extension_377_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_378" number="378" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_378_SPEC_VERSION"/> + <enum value=""XR_MND_extension_378"" name="XR_MND_extension_378_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_379" number="379" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_379_SPEC_VERSION"/> + <enum value=""XR_MND_extension_379"" name="XR_MND_extension_379_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_380" number="380" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_380_SPEC_VERSION"/> + <enum value=""XR_MND_extension_380"" name="XR_MND_extension_380_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_381" number="381" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_381_SPEC_VERSION"/> + <enum value=""XR_MND_extension_381"" name="XR_MND_extension_381_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_382" number="382" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_382_SPEC_VERSION"/> + <enum value=""XR_MND_extension_382"" name="XR_MND_extension_382_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_383" number="383" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_383_SPEC_VERSION"/> + <enum value=""XR_MND_extension_383"" name="XR_MND_extension_383_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_384" number="384" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_384_SPEC_VERSION"/> + <enum value=""XR_MND_extension_384"" name="XR_MND_extension_384_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_controller_interaction" number="385" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="2" name="XR_BD_controller_interaction_SPEC_VERSION"/> + <enum value=""XR_BD_controller_interaction"" name="XR_BD_CONTROLLER_INTERACTION_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/bytedance/pico_neo3_controller"/> + <interaction_profile name="/interaction_profiles/bytedance/pico4_controller"/> + <interaction_profile name="/interaction_profiles/bytedance/pico_g3_controller"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_neo3_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico4_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_g3_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_neo3_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico4_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_g3_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_neo3_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico4_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_g3_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_BD_body_tracking" number="386" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_body_tracking_SPEC_VERSION"/> + <enum value=""XR_BD_body_tracking"" name="XR_BD_BODY_TRACKING_EXTENSION_NAME"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_BODY_TRACKER_BD" comment="XrBodyTrackerBD"/> + <type name="XrBodyTrackerBD"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_BODY_TRACKER_CREATE_INFO_BD"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_BODY_JOINTS_LOCATE_INFO_BD"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_BODY_JOINT_LOCATIONS_BD"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_BD"/> + + <type name="XrBodyJointBD"/> + <type name="XrBodyJointSetBD"/> + + <type name="XrSystemBodyTrackingPropertiesBD"/> + <type name="XrBodyTrackerCreateInfoBD"/> + <type name="XrBodyJointsLocateInfoBD"/> + <type name="XrBodyJointLocationsBD"/> + <type name="XrBodyJointLocationBD"/> + <type name="XR_BODY_JOINT_COUNT_BD"/> + <type name="XR_BODY_JOINT_WITHOUT_ARM_COUNT_BD"/> + + + <command name="xrCreateBodyTrackerBD"/> + <command name="xrDestroyBodyTrackerBD"/> + <command name="xrLocateBodyJointsBD"/> + + </require> + </extension> + + <extension name="XR_BD_facial_simulation" number="387" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_facial_simulation_SPEC_VERSION"/> + <enum value=""XR_BD_facial_simulation"" name="XR_BD_FACIAL_SIMULATION_EXTENSION_NAME"/> + <type name="XrFaceTrackerBD"/> + <type name="XrSystemFacialSimulationPropertiesBD"/> + <type name="XrFaceTrackerCreateInfoBD"/> + <type name="XrFacialSimulationDataGetInfoBD"/> + <type name="XrFacialSimulationDataBD"/> + <type name="XrLipExpressionDataBD"/> + <type name="XrFaceExpressionBD"/> + <type name="XrLipExpressionBD"/> + <type name="XrFacialSimulationModeBD"/> + <type name="XR_FACE_EXPRESSION_COUNT_BD"/> + <type name="XR_LIP_EXPRESSION_COUNT_BD"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_FACE_TRACKER_BD" comment="XrFaceTrackerBD"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SYSTEM_FACIAL_SIMULATION_PROPERTIES_BD"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_FACE_TRACKER_CREATE_INFO_BD"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_FACIAL_SIMULATION_DATA_GET_INFO_BD"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_FACIAL_SIMULATION_DATA_BD"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_LIP_EXPRESSION_DATA_BD"/> + + <command name="xrEnumerateFacialSimulationModesBD"/> + <command name="xrCreateFaceTrackerBD"/> + <command name="xrDestroyFaceTrackerBD"/> + <command name="xrGetFacialSimulationDataBD"/> + <command name="xrSetFacialSimulationModeBD"/> + <command name="xrGetFacialSimulationModeBD"/> + </require> + </extension> + + <extension name="XR_BD_extension_388" number="388" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_388_SPEC_VERSION"/> + <enum value=""XR_BD_extension_388"" name="XR_BD_extension_388_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_389" number="389" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_389_SPEC_VERSION"/> + <enum value=""XR_BD_extension_389"" name="XR_BD_extension_389_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_spatial_sensing" number="390" depends="XR_VERSION_1_0+XR_EXT_future" type="instance" supported="openxr"> + <require> + <enum value="3" name="XR_BD_spatial_sensing_SPEC_VERSION"/> + <enum value=""XR_BD_spatial_sensing"" name="XR_BD_SPATIAL_SENSING_EXTENSION_NAME"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ENTITY_ID_INVALID_BD" comment="The spatial entity id is invalid."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD" comment="The spatial sensing service is unavailable."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_ANCHOR_NOT_SUPPORTED_FOR_ENTITY_BD" comment="The spatial entity does not support anchor."/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPATIAL_SENSING_PROPERTIES_BD"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_COMPONENT_GET_INFO_BD"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_LOCATION_GET_INFO_BD"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_LOCATION_BD"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_SEMANTIC_BD"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_BOUNDING_BOX_2D_BD"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_POLYGON_BD"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_BOUNDING_BOX_3D_BD"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_TRIANGLE_MESH_BD"/> + + <enum offset="9" extends="XrStructureType" name="XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_BD"/> + <enum offset="10" extends="XrStructureType" name="XR_TYPE_SENSE_DATA_PROVIDER_START_INFO_BD"/> + <enum offset="11" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SENSE_DATA_PROVIDER_STATE_CHANGED_BD"/> + <enum offset="12" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SENSE_DATA_UPDATED_BD"/> + <enum offset="13" extends="XrStructureType" name="XR_TYPE_SENSE_DATA_QUERY_INFO_BD"/> + <enum offset="14" extends="XrStructureType" name="XR_TYPE_SENSE_DATA_QUERY_COMPLETION_BD"/> + <enum offset="15" extends="XrStructureType" name="XR_TYPE_SENSE_DATA_FILTER_UUID_BD"/> + <enum offset="16" extends="XrStructureType" name="XR_TYPE_SENSE_DATA_FILTER_SEMANTIC_BD"/> + <enum offset="17" extends="XrStructureType" name="XR_TYPE_QUERIED_SENSE_DATA_GET_INFO_BD"/> + <enum offset="18" extends="XrStructureType" name="XR_TYPE_QUERIED_SENSE_DATA_BD"/> + <enum offset="19" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_STATE_BD"/> + <enum offset="20" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_ANCHOR_CREATE_INFO_BD"/> + <enum offset="21" extends="XrStructureType" name="XR_TYPE_ANCHOR_SPACE_CREATE_INFO_BD"/> + <enum offset="22" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_SPHERE_BD"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SENSE_DATA_PROVIDER_BD" comment="XrSenseDataProviderBD"/> + <enum offset="1" extends="XrObjectType" name="XR_OBJECT_TYPE_SENSE_DATA_SNAPSHOT_BD" comment="XrSenseDataSnapshotBD"/> + <enum offset="2" extends="XrObjectType" name="XR_OBJECT_TYPE_ANCHOR_BD" comment="XrAnchorBD"/> + + <type name="XrSpatialEntityIdBD"/> + <type name="XrSpatialEntityComponentTypeBD"/> + <type name="XrSemanticLabelBD"/> + + <type name="XrSenseDataProviderBD"/> + <type name="XrSenseDataSnapshotBD"/> + <type name="XrSenseDataProviderTypeBD"/> + <type name="XrSenseDataProviderStateBD"/> + + <type name="XrSystemSpatialSensingPropertiesBD"/> + <type name="XrSpatialEntityComponentGetInfoBD"/> + <type name="XrSpatialEntityComponentDataBaseHeaderBD"/> + <type name="XrSpatialEntityLocationGetInfoBD"/> + <type name="XrSpatialEntityComponentDataLocationBD"/> + <type name="XrSpatialEntityComponentDataSemanticBD"/> + <type name="XrSpatialEntityComponentDataBoundingBox2DBD"/> + <type name="XrSpatialEntityComponentDataPolygonBD"/> + <type name="XrSpatialEntityComponentDataBoundingBox3DBD"/> + <type name="XrSpatialEntityComponentDataTriangleMeshBD"/> + <type name="XrSpatialEntityComponentDataSphereBD"/> + + <type name="XrSenseDataProviderCreateInfoBD"/> + <type name="XrSenseDataProviderStartInfoBD"/> + <type name="XrEventDataSenseDataProviderStateChangedBD"/> + <type name="XrEventDataSenseDataUpdatedBD"/> + <type name="XrSenseDataQueryInfoBD"/> + <type name="XrSenseDataQueryCompletionBD"/> + <type name="XrQueriedSenseDataGetInfoBD"/> + <type name="XrQueriedSenseDataBD"/> + <type name="XrSpatialEntityStateBD"/> + <type name="XrSenseDataFilterUuidBD"/> + <type name="XrSenseDataFilterSemanticBD"/> + + <type name="XrAnchorBD"/> + <type name="XrSpatialEntityAnchorCreateInfoBD"/> + <type name="XrAnchorSpaceCreateInfoBD"/> + + + <command name="xrEnumerateSpatialEntityComponentTypesBD"/> + <command name="xrGetSpatialEntityUuidBD"/> + <command name="xrGetSpatialEntityComponentDataBD"/> + + <command name="xrCreateSenseDataProviderBD"/> + <command name="xrStartSenseDataProviderAsyncBD"/> + <command name="xrStartSenseDataProviderCompleteBD"/> + <command name="xrGetSenseDataProviderStateBD"/> + <command name="xrQuerySenseDataAsyncBD"/> + <command name="xrQuerySenseDataCompleteBD"/> + <command name="xrDestroySenseDataSnapshotBD"/> + <command name="xrGetQueriedSenseDataBD"/> + <command name="xrStopSenseDataProviderBD"/> + <command name="xrDestroySenseDataProviderBD"/> + + <command name="xrCreateSpatialEntityAnchorBD"/> + <command name="xrDestroyAnchorBD"/> + <command name="xrGetAnchorUuidBD"/> + <command name="xrCreateAnchorSpaceBD"/> + + + </require> + </extension> + + <extension name="XR_BD_spatial_anchor" number="391" depends="XR_BD_spatial_sensing" type="instance" supported="openxr"> + <require> + <enum value="2" name="XR_BD_spatial_anchor_SPEC_VERSION"/> + <enum value=""XR_BD_spatial_anchor"" name="XR_BD_SPATIAL_ANCHOR_EXTENSION_NAME"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHOR_NOT_FOUND_BD" comment="The spatial anchor is not found."/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPATIAL_ANCHOR_PROPERTIES_BD"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_BD"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_CREATE_COMPLETION_BD"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_PERSIST_INFO_BD"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_UNPERSIST_INFO_BD"/> + + <enum offset="0" extends="XrSenseDataProviderTypeBD" name="XR_SENSE_DATA_PROVIDER_TYPE_ANCHOR_BD" comment="Create arbitrary spatial anchors."/> + + <type name="XrPersistenceLocationBD"/> + <type name="XrSystemSpatialAnchorPropertiesBD"/> + <type name="XrSpatialAnchorCreateInfoBD"/> + <type name="XrSpatialAnchorCreateCompletionBD"/> + <type name="XrSpatialAnchorPersistInfoBD"/> + <type name="XrSpatialAnchorUnpersistInfoBD"/> + + <command name="xrCreateSpatialAnchorAsyncBD"/> + <command name="xrCreateSpatialAnchorCompleteBD"/> + <command name="xrPersistSpatialAnchorAsyncBD"/> + <command name="xrPersistSpatialAnchorCompleteBD"/> + <command name="xrUnpersistSpatialAnchorAsyncBD"/> + <command name="xrUnpersistSpatialAnchorCompleteBD"/> + </require> + </extension> + + <extension name="XR_BD_spatial_anchor_sharing" number="392" depends="XR_BD_spatial_anchor" type="instance" supported="openxr"> + <require> + <enum value="2" name="XR_BD_spatial_anchor_sharing_SPEC_VERSION"/> + <enum value=""XR_BD_spatial_anchor_sharing"" name="XR_BD_SPATIAL_ANCHOR_SHARING_EXTENSION_NAME"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHOR_SHARING_NETWORK_TIMEOUT_BD" comment="The network transmission timeout."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHOR_SHARING_AUTHENTICATION_FAILURE_BD" comment="The authentication for the user account failed."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHOR_SHARING_NETWORK_FAILURE_BD" comment="The network connection failed, e.g. the connection is unstable or disconnected."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHOR_SHARING_LOCALIZATION_FAIL_BD" comment="The spatial anchor localization failed."/> + <enum offset="4" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHOR_SHARING_MAP_INSUFFICIENT_BD" comment="The feature points of spatial anchor map are insufficient."/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPATIAL_ANCHOR_SHARING_PROPERTIES_BD"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_SHARE_INFO_BD"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SHARED_SPATIAL_ANCHOR_DOWNLOAD_INFO_BD"/> + + <type name="XrSystemSpatialAnchorSharingPropertiesBD"/> + <type name="XrSpatialAnchorShareInfoBD"/> + <type name="XrSharedSpatialAnchorDownloadInfoBD"/> + + <command name="xrShareSpatialAnchorAsyncBD"/> + <command name="xrShareSpatialAnchorCompleteBD"/> + <command name="xrDownloadSharedSpatialAnchorAsyncBD"/> + <command name="xrDownloadSharedSpatialAnchorCompleteBD"/> + </require> + </extension> + + <extension name="XR_BD_spatial_scene" number="393" depends="XR_BD_spatial_sensing" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_spatial_scene_SPEC_VERSION"/> + <enum value=""XR_BD_spatial_scene"" name="XR_BD_SPATIAL_SCENE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPATIAL_SCENE_PROPERTIES_BD"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SCENE_CAPTURE_INFO_BD"/> + + <enum offset="0" extends="XrSenseDataProviderTypeBD" name="XR_SENSE_DATA_PROVIDER_TYPE_SCENE_BD" comment="Access spatial scene capture data."/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SCENE_CAPTURE_FAILURE_BD" comment="The scene capture is failed, for example exiting abnormally."/> + + <type name="XrSystemSpatialScenePropertiesBD"/> + <type name="XrSceneCaptureInfoBD"/> + + <command name="xrCaptureSceneAsyncBD"/> + <command name="xrCaptureSceneCompleteBD"/> + + </require> + </extension> + + <extension name="XR_BD_spatial_mesh" number="394" depends="XR_BD_spatial_sensing" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_spatial_mesh_SPEC_VERSION"/> + <enum value=""XR_BD_spatial_mesh"" name="XR_BD_SPATIAL_MESH_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPATIAL_MESH_PROPERTIES_BD"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_SPATIAL_MESH_BD"/> + + <enum offset="0" extends="XrSenseDataProviderTypeBD" name="XR_SENSE_DATA_PROVIDER_TYPE_MESH_BD" comment="Capture spatial mesh data."/> + + <type name="XrSystemSpatialMeshPropertiesBD"/> + <type name="XrSenseDataProviderCreateInfoSpatialMeshBD"/> + + <type name="XrSpatialMeshLodBD"/> + <type name="XrSpatialMeshConfigFlagsBD"/> + <type name="XrSpatialMeshConfigFlagBitsBD"/> + + </require> + </extension> + + <extension name="XR_BD_future_progress" number="395" type="instance" depends="XR_VERSION_1_0+XR_EXT_future" supported="openxr"> + <require> + <enum value="1" name="XR_BD_future_progress_SPEC_VERSION"/> + <enum value=""XR_BD_future_progress"" name="XR_BD_FUTURE_PROGRESS_EXTENSION_NAME"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_FUTURE_POLL_RESULT_PROGRESS_BD"/> + + <type name="XrFuturePollResultProgressBD"/> + </require> + </extension> + + <extension name="XR_BD_body_tracking_auxiliary_metrics" number="396" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_body_tracking_auxiliary_metrics_SPEC_VERSION"/> + <enum value=""XR_BD_body_tracking_auxiliary_metrics"" name="XR_BD_BODY_TRACKING_AUXILIARY_METRICS_EXTENSION_NAME"/> + + <type name="XrBodyTrackingPostureBD"/> + <type name="XrBodyTrackingPostureDataBD"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_BODY_TRACKING_POSTURE_DATA_BD"/> + + <type name="XrBodyJointVelocityBD"/> + <type name="XrBodyJointVelocitiesBD"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_BODY_JOINT_VELOCITIES_BD"/> + + <type name="XrSpaceAccelerationFlagsBD"/> + <type name="XrSpaceAccelerationFlagBitsBD"/> + <type name="XrBodyJointAccelerationBD"/> + <type name="XrBodyJointAccelerationsBD"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_BODY_JOINT_ACCELERATIONS_BD"/> + + <type name="XrBodyTrackingStatusBD"/> + <type name="XrBodyTrackingMessageBD"/> + + <type name="XrBodyTrackingStateBD"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_BODY_TRACKING_STATE_BD"/> + + <command name="xrStartBodyTrackingCalibrationAppBD"/> + <command name="xrGetBodyTrackingStateBD"/> + </require> + </extension> + + <extension name="XR_BD_spatial_plane" number="397" depends="XR_BD_spatial_sensing" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_spatial_plane_SPEC_VERSION"/> + <enum value=""XR_BD_spatial_plane"" name="XR_BD_SPATIAL_PLANE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPATIAL_PLANE_PROPERTIES_BD" comment="XrSystemSpatialPlanePropertiesBD"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_PLANE_ORIENTATION_BD" comment="XrSpatialEntityComponentDataPlaneOrientationBD"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SENSE_DATA_FILTER_PLANE_ORIENTATION_BD" comment="XrSenseDataFilterPlaneOrientationBD"/> + + <enum offset="0" extends="XrSenseDataProviderTypeBD" name="XR_SENSE_DATA_PROVIDER_TYPE_PLANE_BD" comment="Capture spatial plane data."/> + <enum offset="0" extends="XrSpatialEntityComponentTypeBD" name="XR_SPATIAL_ENTITY_COMPONENT_TYPE_PLANE_ORIENTATION_BD" comment="The plane orientation. Corresponds to component data structure slink:XrSpatialEntityComponentDataPlaneOrientationBD."/> + + <type name="XrSystemSpatialPlanePropertiesBD"/> + <type name="XrPlaneOrientationBD"/> + <type name="XrSpatialEntityComponentDataPlaneOrientationBD"/> + <type name="XrSenseDataFilterPlaneOrientationBD"/> + </require> + </extension> + + <extension name="XR_BD_spatial_light_estimation" number="398" depends="XR_BD_spatial_sensing" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_spatial_light_estimation_SPEC_VERSION"/> + <enum value=""XR_BD_spatial_light_estimation"" name="XR_BD_SPATIAL_LIGHT_ESTIMATION_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_LIGHT_ESTIMATION_PROPERTIES_BD"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_LIGHT_ESTIMATION_BD"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_TEXTURE_CREATE_CONFIG_INFO_BD"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_LIGHT_ESTIMATION_DATA_ENVIRONMENT_TEXTURE_RAW_BD"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_LIGHT_ESTIMATION_DATA_SPHERICAL_HARMONICS_BD"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_LIGHT_ESTIMATION_BD"/> + <enum offset="0" extends="XrSpatialEntityComponentTypeBD" name="XR_SPATIAL_ENTITY_COMPONENT_TYPE_LIGHT_ESTIMATION_BD" comment="The light estimate data. Corresponds to component data structure slink:XrSpatialEntityComponentDataLightEstimationBD."/> + <enum offset="0" extends="XrSenseDataProviderTypeBD" name="XR_SENSE_DATA_PROVIDER_TYPE_LIGHT_ESTIMATION_BD" comment="Access spatial light estimate data."/> + + <type name="XrSystemLightEstimationPropertiesBD"/> + <type name="XrLightEstimationCreateFlagsBD"/> + <type name="XrLightEstimationCreateFlagBitsBD"/> + <type name="XrSenseDataProviderCreateInfoLightEstimationBD"/> + <type name="XrEnvironmentTextureCreateConfigInfoBD"/> + <type name="XrLightEstimationDataEnvironmentTextureRawBD"/> + <type name="XrLightEstimationDataSphericalHarmonicsBD"/> + <type name="XrSpatialEntityComponentDataLightEstimationBD"/> + + <type name="XrEnvironmentTexturePixelFormatBD"/> + <type name="XrEnvironmentTextureResolutionBD"/> + <type name="XrEnvironmentTextureTransferTypeBD"/> + <type name="XrSphericalHarmonicsKindBD"/> + + <command name="xrEnumerateEnvironmentTextureResolutionsBD"/> + <command name="xrEnumerateEnvironmentTexturePixelFormatsBD"/> + <command name="xrEnumerateEnvironmentTextureTransferTypesBD"/> + </require> + </extension> + + <extension name="XR_BD_extension_399" number="399" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_399_SPEC_VERSION"/> + <enum value=""XR_BD_extension_399"" name="XR_BD_extension_399_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_400" number="400" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_400_SPEC_VERSION"/> + <enum value=""XR_BD_extension_400"" name="XR_BD_extension_400_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_401" number="401" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_401_SPEC_VERSION"/> + <enum value=""XR_BD_extension_401"" name="XR_BD_extension_401_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_402" number="402" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_402_SPEC_VERSION"/> + <enum value=""XR_BD_extension_402"" name="XR_BD_extension_402_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_403" number="403" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_403_SPEC_VERSION"/> + <enum value=""XR_BD_extension_403"" name="XR_BD_extension_403_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_ultra_controller_interaction" number="404" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_ultra_controller_interaction_SPEC_VERSION"/> + <enum value=""XR_BD_ultra_controller_interaction"" name="XR_BD_ULTRA_CONTROLLER_INTERACTION_EXTENSION_NAME"/> + + <interaction_profile name="/interaction_profiles/bytedance/pico_ultra_controller_bd"/> + </require> + + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_ultra_controller_bd"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_ultra_controller_bd"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_ultra_controller_bd"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + + </extension> + + <extension name="XR_BD_extension_405" number="405" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_405_SPEC_VERSION"/> + <enum value=""XR_BD_extension_405"" name="XR_BD_extension_405_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_406" number="406" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_406_SPEC_VERSION"/> + <enum value=""XR_BD_extension_406"" name="XR_BD_extension_406_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_407" number="407" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_407_SPEC_VERSION"/> + <enum value=""XR_BD_extension_407"" name="XR_BD_extension_407_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_408" number="408" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_408_SPEC_VERSION"/> + <enum value=""XR_BD_extension_408"" name="XR_BD_extension_408_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_409" number="409" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_409_SPEC_VERSION"/> + <enum value=""XR_BD_extension_409"" name="XR_BD_extension_409_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_spatial_audio_rendering" number="410" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_spatial_audio_rendering_SPEC_VERSION"/> + <enum value=""XR_BD_spatial_audio_rendering"" name="XR_BD_SPATIAL_AUDIO_RENDERING_EXTENSION_NAME"/> + + <!-- Structs --> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_AUDIO_RENDERER_CREATE_INFO_BD"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_AUDIO_BUFFER_BD"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SOUND_OBJECT_DIRECTIVITY_CARDIOID_BD"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SOUND_OBJECT_SHAPE_SPHERE_BD"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_SOUND_OBJECT_DISTANCE_ATTENUATION_BD"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_SOUND_OBJECT_DISTANCE_ATTENUATION_CURVE_BD"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_SOUND_OBJECT_CONFIG_BD"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_SOUND_FIELD_CONFIG_BD"/> + <enum offset="9" extends="XrStructureType" name="XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_SURROUND_BD"/> + <enum offset="10" extends="XrStructureType" name="XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_AMBIX_BD"/> + <enum offset="11" extends="XrStructureType" name="XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_FUMA_BD"/> + <enum offset="12" extends="XrStructureType" name="XR_TYPE_SOUND_TRIANGLE_MESH_BD"/> + <enum offset="13" extends="XrStructureType" name="XR_TYPE_SOUND_OBSTACLE_CONFIG_BD"/> + <enum offset="14" extends="XrStructureType" name="XR_TYPE_SOUND_OBSTACLE_MATERIAL_CONFIG_BD"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SPATIAL_AUDIO_RENDERER_BD" comment="XrSpatialAudioRendererBD"/> + <enum offset="1" extends="XrObjectType" name="XR_OBJECT_TYPE_SOUND_FIELD_BD" comment="XrSoundFieldBD"/> + <enum offset="2" extends="XrObjectType" name="XR_OBJECT_TYPE_SOUND_OBJECT_BD" comment="XrSoundObjectBD"/> + <enum offset="3" extends="XrObjectType" name="XR_OBJECT_TYPE_SOUND_OBSTACLE_BD" comment="XrSoundObstacleBD"/> + <enum offset="4" extends="XrObjectType" name="XR_OBJECT_TYPE_SOUND_OBSTACLE_MATERIAL_BD" comment="XrSoundObstacleMaterialBD"/> + + <type name="XrSpatialAudioRendererBD"/> + <type name="XrSoundFieldBD"/> + <type name="XrSoundObjectBD"/> + <type name="XrSoundObstacleBD"/> + <type name="XrSoundObstacleMaterialBD"/> + + <type name="XrSpatialAudioRendererCreateInfoBD"/> + <type name="XrAudioBufferBD"/> + <type name="XrSoundObjectDirectivityCardioidBD"/> + <type name="XrSoundObjectShapeSphereBD"/> + <type name="XrSoundObjectDistanceAttenuationBD"/> + <type name="XrSoundObjectDistanceAttenuationCurveBD"/> + <type name="XrSoundObjectConfigBD"/> + <type name="XrSoundFieldConfigBD"/> + <type name="XrSoundFieldChannelDefinitionSurroundBD"/> + <type name="XrSoundFieldChannelDefinitionAmbixBD"/> + <type name="XrSoundFieldChannelDefinitionFumaBD"/> + <type name="XrSoundFieldChannelMaskSurroundBD"/> + <type name="XrSoundTriangleMeshBD"/> + <type name="XrSoundObstacleConfigBD"/> + <type name="XrSoundObstacleMaterialConfigBD"/> + <type name="XrAttenuationCurvePointBD"/> + <type name="XrAudioSampleRateBD"/> + <type name="XrAudioBufferChannelLayoutBD"/> + <type name="XrSoundObstacleMaterialTypeBD"/> + <type name="XrSoundObjectDistanceAttenuationTypeBD"/> + <type name="XrSoundObstacleFlagsBD"/> + <type name="XrSoundObstacleFlagBitsBD"/> + <type name="XrSoundObjectFlagsBD"/> + <type name="XrSoundObjectFlagBitsBD"/> + <type name="XrSoundFieldChannelMaskSurroundBD"/> + <type name="XrSoundFieldChannelMaskAmbixBD"/> + <type name="XrSoundFieldChannelMaskFumaBD"/> + <type name="XrSoundFieldFlagsBD"/> + <type name="XrSoundFieldFlagBitsBD"/> + + <command name="xrEnumerateSupportedAudioSampleRateBD"/> + <command name="xrQueryFramesPerBufferRangeBD"/> + <command name="xrCreateSpatialAudioRendererBD"/> + <command name="xrDestroySpatialAudioRendererBD"/> + <command name="xrCreateSoundObstacleMaterialBD"/> + <command name="xrUpdateSoundObstacleMaterialConfigBD"/> + <command name="xrDestroySoundObstacleMaterialBD"/> + <command name="xrCreateSoundObstacleBD"/> + <command name="xrUpdateSoundObstacleConfigBD"/> + <command name="xrDestroySoundObstacleBD"/> + <command name="xrCreateSoundObjectBD"/> + <command name="xrUpdateSoundObjectConfigBD"/> + <command name="xrSubmitSoundObjectBufferBD"/> + <command name="xrDestroySoundObjectBD"/> + <command name="xrCreateSoundFieldBD"/> + <command name="xrUpdateSoundFieldConfigBD"/> + <command name="xrSubmitSoundFieldBufferBD"/> + <command name="xrDestroySoundFieldBD"/> + <command name="xrWaitAudioPeriodBD"/> + <command name="xrEndAudioPeriodBD"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_411" number="411" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_411_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_411"" name="XR_MSFT_EXTENSION_411_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_412" number="412" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_412_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_412"" name="XR_MSFT_EXTENSION_412_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_413" number="413" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_413_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_413"" name="XR_MSFT_EXTENSION_413_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_414" number="414" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_414_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_414"" name="XR_MSFT_EXTENSION_414_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_415" number="415" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_415_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_415"" name="XR_MSFT_EXTENSION_415_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_416" number="416" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_416_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_416"" name="XR_MSFT_EXTENSION_416_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_417" number="417" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_417_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_417"" name="XR_MSFT_EXTENSION_417_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_418" number="418" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_418_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_418"" name="XR_MSFT_EXTENSION_418_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_419" number="419" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_419_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_419"" name="XR_MSFT_EXTENSION_419_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_420" number="420" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_420_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_420"" name="XR_MSFT_EXTENSION_420_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_421" number="421" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_421_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_421"" name="XR_MSFT_EXTENSION_421_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_DANWILLM_extension_422" number="422" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_DANWILLM_extension_422_SPEC_VERSION"/> + <enum value=""XR_DANWILLM_extension_422"" name="XR_DANWILLM_EXTENSION_422_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_DANWILLM_extension_423" number="423" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_DANWILLM_extension_423_SPEC_VERSION"/> + <enum value=""XR_DANWILLM_extension_423"" name="XR_DANWILLM_EXTENSION_423_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_DANWILLM_extension_424" number="424" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_DANWILLM_extension_424_SPEC_VERSION"/> + <enum value=""XR_DANWILLM_extension_424"" name="XR_DANWILLM_EXTENSION_424_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_DANWILLM_extension_425" number="425" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_DANWILLM_extension_425_SPEC_VERSION"/> + <enum value=""XR_DANWILLM_extension_425"" name="XR_DANWILLM_EXTENSION_425_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_DANWILLM_extension_426" number="426" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_DANWILLM_extension_426_SPEC_VERSION"/> + <enum value=""XR_DANWILLM_extension_426"" name="XR_DANWILLM_EXTENSION_426_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_local_floor" number="427" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="1" name="XR_EXT_local_floor_SPEC_VERSION"/> + <enum value=""XR_EXT_local_floor"" name="XR_EXT_LOCAL_FLOOR_EXTENSION_NAME"/> + <enum extends="XrReferenceSpaceType" name="XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR_EXT" alias="XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR"/> + </require> + </extension> + + <extension name="XR_LOGITECH_extension_428" number="428" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LOGITECH_extension_428_SPEC_VERSION"/> + <enum value=""XR_LOGITECH_extension_428"" name="XR_LOGITECH_EXTENSION_428_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_hand_tracking_data_source" number="429" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_EXT_hand_tracking" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_hand_tracking_data_source_SPEC_VERSION"/> + <enum value=""XR_EXT_hand_tracking_data_source"" name="XR_EXT_HAND_TRACKING_DATA_SOURCE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_HAND_TRACKING_DATA_SOURCE_INFO_EXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_HAND_TRACKING_DATA_SOURCE_STATE_EXT"/> + + <type name="XrHandTrackingDataSourceEXT"/> + <type name="XrHandTrackingDataSourceInfoEXT"/> + <type name="XrHandTrackingDataSourceStateEXT"/> + </require> + </extension> + + <extension name="XR_EXT_plane_detection" number="430" type="instance" supported="openxr" deprecatedby="XR_EXT_spatial_plane_tracking"> + <require> + <enum value="2" name="XR_EXT_plane_detection_SPEC_VERSION"/> + <enum value=""XR_EXT_plane_detection"" name="XR_EXT_PLANE_DETECTION_EXTENSION_NAME"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SPACE_NOT_LOCATABLE_EXT" comment="The space passed to the function was not locatable."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_PLANE_DETECTION_PERMISSION_DENIED_EXT" comment="The permission for this resource was not granted."/> + + <command name="xrCreatePlaneDetectorEXT"/> + <command name="xrDestroyPlaneDetectorEXT"/> + <command name="xrBeginPlaneDetectionEXT"/> + <command name="xrGetPlaneDetectionStateEXT"/> + <command name="xrGetPlaneDetectionsEXT"/> + <command name="xrGetPlanePolygonBufferEXT"/> + + <type name="XrSystemPlaneDetectionPropertiesEXT"/> + <type name="XrPlaneDetectionCapabilityFlagsEXT"/> + <type name="XrPlaneDetectionCapabilityFlagBitsEXT"/> + <type name="XrPlaneDetectorEXT"/> + <type name="XrPlaneDetectorCreateInfoEXT"/> + <type name="XrPlaneDetectorBeginInfoEXT"/> + <type name="XrPlaneDetectionStateEXT"/> + <type name="XrPlaneDetectorGetInfoEXT"/> + <type name="XrPlaneDetectorLocationEXT"/> + <type name="XrPlaneDetectorLocationsEXT"/> + <type name="XrPlaneDetectorPolygonBufferEXT"/> + <type name="XrPlaneDetectorFlagsEXT"/> + <type name="XrPlaneDetectorFlagBitsEXT"/> + <type name="XrPlaneDetectorSemanticTypeEXT"/> + <type name="XrPlaneDetectorOrientationEXT"/> + <type name="XrExtent3DfEXT"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_PLANE_DETECTOR_EXT" comment="XrPlaneDetectorEXT"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_PLANE_DETECTOR_CREATE_INFO_EXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_PLANE_DETECTOR_BEGIN_INFO_EXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_PLANE_DETECTOR_GET_INFO_EXT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_PLANE_DETECTOR_LOCATIONS_EXT"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_PLANE_DETECTOR_LOCATION_EXT"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_PLANE_DETECTOR_POLYGON_BUFFER_EXT"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_SYSTEM_PLANE_DETECTION_PROPERTIES_EXT"/> + + </require> + </extension> + + <extension name="XR_ACER_extension_431" number="431" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_431_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_431"" name="XR_ACER_EXTENSION_431_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_432" number="432" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_432_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_432"" name="XR_ACER_EXTENSION_432_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_433" number="433" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_433_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_433"" name="XR_ACER_EXTENSION_433_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_434" number="434" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_434_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_434"" name="XR_ACER_EXTENSION_434_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_435" number="435" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_435_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_435"" name="XR_ACER_EXTENSION_435_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_436" number="436" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_436_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_436"" name="XR_ACER_EXTENSION_436_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_437" number="437" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_437_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_437"" name="XR_ACER_EXTENSION_437_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_438" number="438" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_438_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_438"" name="XR_ACER_EXTENSION_438_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_439" number="439" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_439_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_439"" name="XR_ACER_EXTENSION_439_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_440" number="440" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_440_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_440"" name="XR_ACER_EXTENSION_440_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_441" number="441" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_441_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_441"" name="XR_ACER_EXTENSION_441_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_442" number="442" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_442_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_442"" name="XR_ACER_EXTENSION_442_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_443" number="443" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_443_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_443"" name="XR_ACER_EXTENSION_443_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_444" number="444" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_444_SPEC_VERSION"/> + <enum value=""XR_MND_extension_444"" name="XR_MND_EXTENSION_444_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MNDX_xdev_space" number="445" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MNDX_xdev_space_SPEC_VERSION"/> + <enum value=""XR_MNDX_xdev_space"" name="XR_MNDX_XDEV_SPACE_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_446" number="446" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_446_SPEC_VERSION"/> + <enum value=""XR_MND_extension_446"" name="XR_MND_EXTENSION_446_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_447" number="447" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_447_SPEC_VERSION"/> + <enum value=""XR_MND_extension_447"" name="XR_MND_EXTENSION_447_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_448" number="448" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_448_SPEC_VERSION"/> + <enum value=""XR_MND_extension_448"" name="XR_MND_EXTENSION_448_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_449" number="449" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_449_SPEC_VERSION"/> + <enum value=""XR_MND_extension_449"" name="XR_MND_EXTENSION_449_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_450" number="450" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_450_SPEC_VERSION"/> + <enum value=""XR_MND_extension_450"" name="XR_MND_EXTENSION_450_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_451" number="451" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_451_SPEC_VERSION"/> + <enum value=""XR_MND_extension_451"" name="XR_MND_EXTENSION_451_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_452" number="452" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_452_SPEC_VERSION"/> + <enum value=""XR_MND_extension_452"" name="XR_MND_EXTENSION_452_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_453" number="453" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_453_SPEC_VERSION"/> + <enum value=""XR_MND_extension_453"" name="XR_MND_EXTENSION_453_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_OPPO_controller_interaction" number="454" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_OPPO_controller_interaction_SPEC_VERSION"/> + <enum value=""XR_OPPO_controller_interaction"" name="XR_OPPO_CONTROLLER_INTERACTION_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/oppo/mr_controller_oppo"/> + </require> + + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/oppo/mr_controller_oppo"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/oppo/mr_controller_oppo"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/oppo/mr_controller_oppo"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_ANDROID_extension_455" number="455" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_455_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_455"" name="XR_ANDROID_EXTENSION_455_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_trackables" number="456" type="instance" fragment="true"/> + + <extension name="XR_ANDROID_eye_tracking" number="457" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ANDROID_eye_tracking_SPEC_VERSION"/> + <enum value=""XR_ANDROID_eye_tracking"" name="XR_ANDROID_EYE_TRACKING_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_EYES_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_EYE_TRACKER_CREATE_INFO_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_EYES_GET_INFO_ANDROID"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SYSTEM_EYE_TRACKING_PROPERTIES_ANDROID"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_EYE_TRACKER_ANDROID" comment="XrEyeTrackerANDROID"/> + + <enum value="2" name="XR_EYE_MAX_ANDROID"/> + + <type name="XrSystemEyeTrackingPropertiesANDROID"/> + <type name="XrEyeTrackerANDROID"/> + <type name="XrEyeIndexANDROID"/> + <type name="XrEyeStateANDROID"/> + <type name="XrEyeTrackingModeANDROID"/> + <type name="XrEyeANDROID"/> + <type name="XrEyesANDROID"/> + <type name="XrEyesGetInfoANDROID"/> + <type name="XrEyeTrackerCreateInfoANDROID"/> + + <command name="xrCreateEyeTrackerANDROID"/> + <command name="xrDestroyEyeTrackerANDROID"/> + <command name="xrGetFineTrackingEyesInfoANDROID"/> + <command name="xrGetCoarseTrackingEyesInfoANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_device_anchor_persistence" number="458" type="instance" depends="XR_EXT_uuid+XR_ANDROID_trackables" supported="openxr" deprecatedby="XR_EXT_spatial_persistence+XR_EXT_spatial_persistence_operations"> + <require> + <enum value="1" name="XR_ANDROID_device_anchor_persistence_SPEC_VERSION"/> + <enum value=""XR_ANDROID_device_anchor_persistence"" name="XR_ANDROID_DEVICE_ANCHOR_PERSISTENCE_EXTENSION_NAME"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_PERSISTED_ANCHOR_SPACE_CREATE_INFO_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_PERSISTED_ANCHOR_SPACE_INFO_ANDROID"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_DEVICE_ANCHOR_PERSISTENCE_CREATE_INFO_ANDROID"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SYSTEM_DEVICE_ANCHOR_PERSISTENCE_PROPERTIES_ANDROID"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_ANCHOR_ID_NOT_FOUND_ANDROID" comment="XrUuidExt passed to the function was not found to be a persisted anchor."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_ANCHOR_ALREADY_PERSISTED_ANDROID" comment="XrUuidExt passed to the function was already marked to be persisted."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_ANCHOR_NOT_TRACKING_ANDROID" comment="ANchor cannot be persisted because it is not tracking."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_PERSISTED_DATA_NOT_READY_ANDROID" comment="Persisted data stored by this app has not been loaded yet."/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_DEVICE_ANCHOR_PERSISTENCE_ANDROID" comment="XrDeviceAnchorPersistenceANDROID"/> + + <type name="XrDeviceAnchorPersistenceANDROID"/> + <type name="XrDeviceAnchorPersistenceCreateInfoANDROID"/> + <type name="XrPersistedAnchorSpaceCreateInfoANDROID"/> + <type name="XrPersistedAnchorSpaceInfoANDROID"/> + <type name="XrAnchorPersistStateANDROID"/> + <type name="XrSystemDeviceAnchorPersistencePropertiesANDROID"/> + + <command name="xrEnumerateSupportedPersistenceAnchorTypesANDROID"/> + <command name="xrCreateDeviceAnchorPersistenceANDROID"/> + <command name="xrDestroyDeviceAnchorPersistenceANDROID"/> + <command name="xrPersistAnchorANDROID"/> + <command name="xrGetAnchorPersistStateANDROID"/> + <command name="xrCreatePersistedAnchorSpaceANDROID"/> + <command name="xrEnumeratePersistedAnchorsANDROID"/> + <command name="xrUnpersistAnchorANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_face_tracking" number="459" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ANDROID_face_tracking_SPEC_VERSION"/> + <enum value=""XR_ANDROID_face_tracking"" name="XR_ANDROID_FACE_TRACKING_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_FACE_TRACKER_CREATE_INFO_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_FACE_STATE_GET_INFO_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_FACE_STATE_ANDROID"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES_ANDROID"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SERVICE_NOT_READY_ANDROID" comment="The underlying tracking service is not yet ready."/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_FACE_TRACKER_ANDROID" comment="XrFaceTrackerANDROID"/> + + <enum value="68" name="XR_FACE_PARAMETER_COUNT_ANDROID"/> + <enum value="3" name="XR_FACE_REGION_CONFIDENCE_COUNT_ANDROID"/> + + <type name="XrFaceTrackerANDROID"/> + <type name="XrFaceParameterIndicesANDROID"/> + <type name="XrFaceTrackingStateANDROID"/> + <type name="XrFaceConfidenceRegionsANDROID"/> + <type name="XrFaceTrackerCreateInfoANDROID"/> + <type name="XrFaceStateGetInfoANDROID"/> + <type name="XrFaceStateANDROID"/> + <type name="XrSystemFaceTrackingPropertiesANDROID"/> + + <command name="xrCreateFaceTrackerANDROID"/> + <command name="xrDestroyFaceTrackerANDROID"/> + <command name="xrGetFaceStateANDROID"/> + <command name="xrGetFaceCalibrationStateANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_460" number="460" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_460_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_460"" name="XR_ANDROID_extension_460_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_passthrough_camera_state" number="461" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ANDROID_passthrough_camera_state_SPEC_VERSION"/> + <enum value=""XR_ANDROID_passthrough_camera_state"" name="XR_ANDROID_PASSTHROUGH_CAMERA_STATE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_CAMERA_STATE_GET_INFO_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SYSTEM_PASSTHROUGH_CAMERA_STATE_PROPERTIES_ANDROID"/> + + <type name="XrSystemPassthroughCameraStatePropertiesANDROID"/> + <type name="XrPassthroughCameraStateANDROID"/> + <type name="XrPassthroughCameraStateGetInfoANDROID"/> + + <command name="xrGetPassthroughCameraStateANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_recommended_resolution" number="462" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ANDROID_recommended_resolution_SPEC_VERSION"/> + <enum value=""XR_ANDROID_recommended_resolution"" name="XR_ANDROID_RECOMMENDED_RESOLUTION_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_RECOMMENDED_RESOLUTION_CHANGED_ANDROID"/> + <type name="XrEventDataRecommendedResolutionChangedANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_composition_layer_passthrough_mesh" number="463" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ANDROID_composition_layer_passthrough_mesh_SPEC_VERSION"/> + <enum value=""XR_ANDROID_composition_layer_passthrough_mesh"" name="XR_ANDROID_COMPOSITION_LAYER_PASSTHROUGH_MESH_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_LAYER_MESH_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_ANDROID"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SYSTEM_PASSTHROUGH_LAYER_PROPERTIES_ANDROID"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_MESH_DATA_LIMIT_EXCEEDED_ANDROID" comment="Returned by passthrough layer functions to indicate the mesh data exceeds the supported limit."/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_PASSTHROUGH_LAYER_ANDROID" comment="XrPassthroughLayerANDROID"/> + + <type name="XrPassthroughLayerANDROID"/> + <type name="XrWindingOrderANDROID"/> + <type name="XrPassthroughLayerCreateInfoANDROID"/> + <type name="XrPassthroughLayerMeshANDROID"/> + <type name="XrCompositionLayerPassthroughANDROID"/> + <type name="XrSystemPassthroughLayerPropertiesANDROID"/> + + <command name="xrCreatePassthroughLayerANDROID"/> + <command name="xrDestroyPassthroughLayerANDROID"/> + <command name="xrSetPassthroughLayerMeshANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_raycast" number="464" type="instance" supported="openxr" depends="XR_ANDROID_trackables" deprecatedby="XR_ANDROID_spatial_discovery_raycast"> + <require> + <enum value="1" name="XR_ANDROID_raycast_SPEC_VERSION"/> + <enum value=""XR_ANDROID_raycast"" name="XR_ANDROID_RAYCAST_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_RAYCAST_INFO_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_RAYCAST_HIT_RESULTS_ANDROID"/> + + <enum offset="0" extends="XrTrackableTypeANDROID" name="XR_TRACKABLE_TYPE_DEPTH_ANDROID" comment="Indicates that the trackable is the perception depth buffer."/> + + <type name="XrRaycastInfoANDROID"/> + <type name="XrRaycastHitResultANDROID"/> + <type name="XrRaycastHitResultsANDROID"/> + + <command name="xrEnumerateRaycastSupportedTrackableTypesANDROID"/> + <command name="xrRaycastANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_465" number="465" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_465_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_465"" name="XR_ANDROID_extension_465_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_performance_metrics" number="466" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ANDROID_performance_metrics_SPEC_VERSION"/> + <enum value=""XR_ANDROID_performance_metrics"" name="XR_ANDROID_PERFORMANCE_METRICS_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_PERFORMANCE_METRICS_STATE_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_PERFORMANCE_METRICS_COUNTER_ANDROID"/> + + <type name="XrPerformanceMetricsCounterUnitANDROID"/> + <type name="XrPerformanceMetricsCounterFlagsANDROID"/> + <type name="XrPerformanceMetricsStateANDROID"/> + <type name="XrPerformanceMetricsCounterANDROID"/> + <type name="XrPerformanceMetricsCounterFlagBitsANDROID"/> + + <command name="xrEnumeratePerformanceMetricsCounterPathsANDROID"/> + <command name="xrSetPerformanceMetricsStateANDROID"/> + <command name="xrGetPerformanceMetricsStateANDROID"/> + <command name="xrQueryPerformanceMetricsCounterANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_trackables_object" number="467" type="instance" supported="openxr" depends="XR_ANDROID_trackables" deprecatedby="XR_ANDROID_spatial_object_tracking"> + <require> + <enum value="2" name="XR_ANDROID_trackables_object_SPEC_VERSION"/> + <enum value=""XR_ANDROID_trackables_object"" name="XR_ANDROID_TRACKABLES_OBJECT_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_TRACKABLE_OBJECT_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_TRACKABLE_OBJECT_CONFIGURATION_ANDROID"/> + <enum offset="0" extends="XrTrackableTypeANDROID" name="XR_TRACKABLE_TYPE_OBJECT_ANDROID" comment="Indicates that the trackable is the object."/> + + <type name="XrObjectLabelANDROID"/> + <type name="XrTrackableObjectANDROID"/> + <type name="XrTrackableObjectConfigurationANDROID"/> + + <command name="xrGetTrackableObjectANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_unbounded_reference_space" number="468" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ANDROID_unbounded_reference_space_SPEC_VERSION"/> + <enum value=""XR_ANDROID_unbounded_reference_space"" name="XR_ANDROID_UNBOUNDED_REFERENCE_SPACE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrReferenceSpaceType" name="XR_REFERENCE_SPACE_TYPE_UNBOUNDED_ANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_469" number="469" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_469_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_469"" name="XR_ANDROID_extension_469_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_future" number="470" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="2" name="XR_EXT_future_SPEC_VERSION"/> + <enum value=""XR_EXT_future"" name="XR_EXT_FUTURE_EXTENSION_NAME"/> + + <enum value="0" name="XR_NULL_FUTURE_EXT"/> + + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_FUTURE_PENDING_EXT" comment="Returned by completion function to indicate future is not ready."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_FUTURE_INVALID_EXT" comment="Returned by completion function to indicate future is not valid."/> + + <type name="XrFutureEXT"/> + <type name="XrFutureStateEXT"/> + + <type name="XrFutureCancelInfoEXT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_FUTURE_CANCEL_INFO_EXT"/> + + <type name="XrFuturePollInfoEXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_FUTURE_POLL_INFO_EXT"/> + + <type name="XrFutureCompletionBaseHeaderEXT"/> + <type name="XrFutureCompletionEXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_FUTURE_COMPLETION_EXT"/> + + <type name="XrFuturePollResultEXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_FUTURE_POLL_RESULT_EXT"/> + + + <command name="xrPollFutureEXT"/> + <command name="xrCancelFutureEXT"/> + + </require> + </extension> + + <extension name="XR_EXT_user_presence" number="471" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_EXT_user_presence_SPEC_VERSION"/> + <enum value=""XR_EXT_user_presence"" name="XR_EXT_USER_PRESENCE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_USER_PRESENCE_CHANGED_EXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SYSTEM_USER_PRESENCE_PROPERTIES_EXT"/> + + <type name="XrEventDataUserPresenceChangedEXT"/> + <type name="XrSystemUserPresencePropertiesEXT"/> + </require> + </extension> + + <extension name="XR_KHR_locate_spaces" number="472" type="instance" supported="openxr" promotedto="XR_VERSION_1_1" ratified="openxr"> + <require> + <enum value="1" name="XR_KHR_locate_spaces_SPEC_VERSION"/> + <enum value=""XR_KHR_locate_spaces"" name="XR_KHR_LOCATE_SPACES_EXTENSION_NAME"/> + <enum extends="XrStructureType" name="XR_TYPE_SPACES_LOCATE_INFO_KHR" alias="XR_TYPE_SPACES_LOCATE_INFO"/> + <enum extends="XrStructureType" name="XR_TYPE_SPACE_LOCATIONS_KHR" alias="XR_TYPE_SPACE_LOCATIONS"/> + <enum extends="XrStructureType" name="XR_TYPE_SPACE_VELOCITIES_KHR" alias="XR_TYPE_SPACE_VELOCITIES"/> + + <type name="XrSpacesLocateInfoKHR"/> + <type name="XrSpaceLocationDataKHR"/> + <type name="XrSpaceLocationsKHR"/> + <type name="XrSpaceVelocityDataKHR"/> + <type name="XrSpaceVelocitiesKHR"/> + + <command name="xrLocateSpacesKHR"/> + </require> + </extension> + + <extension name="XR_ML_system_notifications" number="474" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ML_system_notifications_SPEC_VERSION"/> + <enum value=""XR_ML_system_notifications"" name="XR_ML_SYSTEM_NOTIFICATIONS_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_NOTIFICATIONS_SET_INFO_ML"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SYSTEM_NOTIFICATION_PERMISSION_DENIED_ML" comment="The com.magicleap.permission.SYSTEM_NOTIFICATION permission was not granted."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SYSTEM_NOTIFICATION_INCOMPATIBLE_SKU_ML" comment="Incompatible SKU detected."/> + + <type name="XrSystemNotificationsSetInfoML"/> + + <command name="xrSetSystemNotificationsML"/> + </require> + </extension> + + <extension name="XR_ML_world_mesh_detection" number="475" type="instance" depends="XR_EXT_future" supported="openxr"> + <require> + <enum value="1" name="XR_ML_world_mesh_detection_SPEC_VERSION"/> + <enum value=""XR_ML_world_mesh_detection"" name="XR_ML_WORLD_MESH_DETECTION_EXTENSION_NAME"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_WORLD_MESH_DETECTOR_ML" comment="XrWorldMeshDetectorML"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_WORLD_MESH_DETECTOR_PERMISSION_DENIED_ML" comment="The world mesh detector permission was not granted."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_WORLD_MESH_DETECTOR_SPACE_NOT_LOCATABLE_ML" comment="At the time of the call the runtime was unable to locate the space and cannot fulfill your request."/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_DETECTOR_CREATE_INFO_ML"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_STATE_REQUEST_INFO_ML"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_BLOCK_STATE_ML"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_STATE_REQUEST_COMPLETION_ML"/> + + <enum offset="5" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_BUFFER_RECOMMENDED_SIZE_INFO_ML"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_BUFFER_SIZE_ML"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_BUFFER_ML"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_BLOCK_REQUEST_ML"/> + <enum offset="9" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_GET_INFO_ML"/> + <enum offset="10" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_BLOCK_ML"/> + <enum offset="11" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_REQUEST_COMPLETION_ML"/> + <enum offset="12" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_REQUEST_COMPLETION_INFO_ML"/> + + + <type name="XrWorldMeshDetectorML"/> + + <type name="XrWorldMeshDetectorFlagsML"/> + <type name="XrWorldMeshDetectorFlagBitsML"/> + <type name="XrWorldMeshDetectorLodML"/> + <type name="XrWorldMeshBlockStatusML"/> + <type name="XrWorldMeshBlockResultML"/> + + <type name="XrWorldMeshDetectorCreateInfoML"/> + <type name="XrWorldMeshBlockStateML"/> + <type name="XrWorldMeshStateRequestInfoML"/> + <type name="XrWorldMeshStateRequestCompletionML"/> + + <type name="XrWorldMeshBufferRecommendedSizeInfoML"/> + <type name="XrWorldMeshBufferSizeML"/> + <type name="XrWorldMeshBufferML"/> + <type name="XrWorldMeshBlockRequestML"/> + <type name="XrWorldMeshGetInfoML"/> + <type name="XrWorldMeshBlockML"/> + <type name="XrWorldMeshRequestCompletionInfoML"/> + <type name="XrWorldMeshRequestCompletionML"/> + + <command name="xrCreateWorldMeshDetectorML"/> + <command name="xrDestroyWorldMeshDetectorML"/> + <command name="xrRequestWorldMeshStateAsyncML"/> + <command name="xrRequestWorldMeshStateCompleteML"/> + <command name="xrGetWorldMeshBufferRecommendSizeML"/> + <command name="xrAllocateWorldMeshBufferML"/> + <command name="xrFreeWorldMeshBufferML"/> + <command name="xrRequestWorldMeshAsyncML"/> + <command name="xrRequestWorldMeshCompleteML"/> + + </require> + </extension> + + <extension name="XR_ML_extension_476" number="476" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_476_SPEC_VERSION"/> + <enum value=""XR_ML_extension_476"" name="XR_ML_extension_476_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_477" number="477" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_477_SPEC_VERSION"/> + <enum value=""XR_ML_extension_477"" name="XR_ML_extension_477_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_478" number="478" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_478_SPEC_VERSION"/> + <enum value=""XR_ML_extension_478"" name="XR_ML_extension_478_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_479" number="479" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_479_SPEC_VERSION"/> + <enum value=""XR_ML_extension_479"" name="XR_ML_extension_479_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_480" number="480" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_480_SPEC_VERSION"/> + <enum value=""XR_ML_extension_480"" name="XR_ML_extension_480_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_481" number="481" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_481_SPEC_VERSION"/> + <enum value=""XR_ML_extension_481"" name="XR_ML_extension_481_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_482" number="482" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_482_SPEC_VERSION"/> + <enum value=""XR_ML_extension_482"" name="XR_ML_extension_482_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_facial_expression" number="483" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ML_facial_expression_SPEC_VERSION"/> + <enum value=""XR_ML_facial_expression"" name="XR_ML_FACIAL_EXPRESSION_EXTENSION_NAME"/> + + <enum offset="0" extends="XrResult" name="XR_ERROR_FACIAL_EXPRESSION_PERMISSION_DENIED_ML" comment="Permission to track facial expressions was not granted"/> + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_FACIAL_EXPRESSION_CLIENT_ML" comment="XrFacialExpressionClientML"/> + + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SYSTEM_FACIAL_EXPRESSION_PROPERTIES_ML"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_FACIAL_EXPRESSION_CLIENT_CREATE_INFO_ML"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_FACIAL_EXPRESSION_BLEND_SHAPE_GET_INFO_ML"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_ML"/> + + <type name="XrFacialExpressionClientML"/> + + <type name="XrFacialBlendShapeML"/> + <type name="XrSystemFacialExpressionPropertiesML"/> + <type name="XrFacialExpressionClientCreateInfoML"/> + <type name="XrFacialExpressionBlendShapeGetInfoML"/> + <type name="XrFacialExpressionBlendShapePropertiesML"/> + <type name="XrFacialExpressionBlendShapePropertiesFlagsML"/> + <type name="XrFacialExpressionBlendShapePropertiesFlagBitsML"/> + + <command name="xrCreateFacialExpressionClientML"/> + <command name="xrDestroyFacialExpressionClientML"/> + <command name="xrGetFacialExpressionBlendShapePropertiesML"/> + </require> + </extension> + + <extension name="XR_ML_view_configuration_depth_range_change" number="484" depends="XR_EXT_view_configuration_depth_range" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ML_view_configuration_depth_range_change_SPEC_VERSION"/> + <enum value=""XR_ML_view_configuration_depth_range_change"" name="XR_ML_VIEW_CONFIGURATION_DEPTH_RANGE_CHANGE_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_485" number="485" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_485_SPEC_VERSION"/> + <enum value=""XR_ML_extension_485"" name="XR_ML_extension_485_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_486" number="486" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_486_SPEC_VERSION"/> + <enum value=""XR_ML_extension_486"" name="XR_ML_extension_486_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_487" number="487" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_487_SPEC_VERSION"/> + <enum value=""XR_ML_extension_487"" name="XR_ML_extension_487_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_488" number="488" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_488_SPEC_VERSION"/> + <enum value=""XR_ML_extension_488"" name="XR_ML_extension_488_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_489" number="489" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_489_SPEC_VERSION"/> + <enum value=""XR_ML_extension_489"" name="XR_ML_extension_489_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_490" number="490" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_490_SPEC_VERSION"/> + <enum value=""XR_ML_extension_490"" name="XR_ML_extension_490_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_491" number="491" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_491_SPEC_VERSION"/> + <enum value=""XR_ML_extension_491"" name="XR_ML_extension_491_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_492" number="492" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_492_SPEC_VERSION"/> + <enum value=""XR_ML_extension_492"" name="XR_ML_extension_492_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_493" number="493" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_493_SPEC_VERSION"/> + <enum value=""XR_ML_extension_493"" name="XR_ML_extension_493_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_494" number="494" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_494_SPEC_VERSION"/> + <enum value=""XR_ML_extension_494"" name="XR_ML_extension_494_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_495" number="495" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_495_SPEC_VERSION"/> + <enum value=""XR_ML_extension_495"" name="XR_ML_extension_495_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_496" number="496" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_496_SPEC_VERSION"/> + <enum value=""XR_ML_extension_496"" name="XR_ML_extension_496_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_497" number="497" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_497_SPEC_VERSION"/> + <enum value=""XR_ML_extension_497"" name="XR_ML_extension_497_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_controller_interaction" number="498" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_YVR_controller_interaction_SPEC_VERSION"/> + <enum value=""XR_YVR_controller_interaction"" name="XR_YVR_CONTROLLER_INTERACTION_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/yvr/touch_controller_yvr"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/yvr/touch_controller_yvr"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/yvr/touch_controller_yvr"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/yvr/touch_controller_yvr"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_YVR_extension_499" number="499" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_499_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_499"" name="XR_YVR_extension_499_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_500" number="500" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_500_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_500"" name="XR_YVR_extension_500_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_501" number="501" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_501_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_501"" name="XR_YVR_extension_501_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_502" number="502" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_502_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_502"" name="XR_YVR_extension_502_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_503" number="503" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_503_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_503"" name="XR_YVR_extension_503_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_504" number="504" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_504_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_504"" name="XR_YVR_extension_504_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_505" number="505" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_505_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_505"" name="XR_YVR_extension_505_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_506" number="506" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_506_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_506"" name="XR_YVR_extension_506_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_507" number="507" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_507_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_507"" name="XR_YVR_extension_507_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_508" number="508" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_508_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_508"" name="XR_YVR_extension_508_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_509" number="509" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_509_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_509"" name="XR_YVR_extension_509_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_510" number="510" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_510_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_510"" name="XR_YVR_extension_510_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_511" number="511" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_511_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_511"" name="XR_YVR_extension_511_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_512" number="512" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_512_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_512"" name="XR_YVR_extension_512_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_513" number="513" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_513_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_513"" name="XR_YVR_extension_513_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_514" number="514" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_514_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_514"" name="XR_YVR_extension_514_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_515" number="515" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_515_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_515"" name="XR_YVR_extension_515_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_516" number="516" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_516_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_516"" name="XR_YVR_extension_516_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_517" number="517" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_517_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_517"" name="XR_YVR_extension_517_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_518" number="518" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_518_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_518"" name="XR_YVR_extension_518_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_519" number="519" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_519_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_519"" name="XR_YVR_extension_519_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_520" number="520" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_520_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_520"" name="XR_YVR_extension_520_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_521" number="521" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_521_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_521"" name="XR_YVR_extension_521_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_522" number="522" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_522_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_522"" name="XR_YVR_extension_522_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_523" number="523" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_523_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_523"" name="XR_YVR_extension_523_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_524" number="524" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_524_SPEC_VERSION"/> + <enum value=""XR_NV_extension_524"" name="XR_NV_extension_524_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_525" number="525" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_525_SPEC_VERSION"/> + <enum value=""XR_NV_extension_525"" name="XR_NV_extension_525_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_526" number="526" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_526_SPEC_VERSION"/> + <enum value=""XR_NV_extension_526"" name="XR_NV_extension_526_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_527" number="527" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_527_SPEC_VERSION"/> + <enum value=""XR_NV_extension_527"" name="XR_NV_extension_527_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_528" number="528" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_528_SPEC_VERSION"/> + <enum value=""XR_NV_extension_528"" name="XR_NV_extension_528_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_boundary_visibility" number="529" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_boundary_visibility_SPEC_VERSION"/> + <enum value=""XR_META_boundary_visibility"" name="XR_META_BOUNDARY_VISIBILITY_EXTENSION_NAME"/> + + <enum offset="0" extends="XrResult" name="XR_BOUNDARY_VISIBILITY_SUPPRESSION_NOT_ALLOWED_META" comment="Runtime did not accept the request to suppress the boundary visibility"/> + + <type name="XrSystemBoundaryVisibilityPropertiesMETA"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_BOUNDARY_VISIBILITY_PROPERTIES_META"/> + <type name="XrEventDataBoundaryVisibilityChangedMETA"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_BOUNDARY_VISIBILITY_CHANGED_META"/> + + <type name="XrBoundaryVisibilityMETA"/> + + <command name="xrRequestBoundaryVisibilityMETA"/> + </require> + </extension> + + <extension name="XR_META_extension_530" number="530" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_530_SPEC_VERSION"/> + <enum value=""XR_META_extension_530"" name="XR_META_extension_530_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_531" number="531" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_531_SPEC_VERSION"/> + <enum value=""XR_META_extension_531"" name="XR_META_extension_531_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_532" number="532" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_532_SPEC_VERSION"/> + <enum value=""XR_META_extension_532"" name="XR_META_extension_532_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_simultaneous_hands_and_controllers" number="533" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_simultaneous_hands_and_controllers_SPEC_VERSION"/> + <enum value=""XR_META_simultaneous_hands_and_controllers"" name="XR_META_SIMULTANEOUS_HANDS_AND_CONTROLLERS_EXTENSION_NAME"/> + + <type name="XrSystemSimultaneousHandsAndControllersPropertiesMETA"/> + <type name="XrSimultaneousHandsAndControllersTrackingResumeInfoMETA"/> + <type name="XrSimultaneousHandsAndControllersTrackingPauseInfoMETA"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SYSTEM_SIMULTANEOUS_HANDS_AND_CONTROLLERS_PROPERTIES_META"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SIMULTANEOUS_HANDS_AND_CONTROLLERS_TRACKING_RESUME_INFO_META"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SIMULTANEOUS_HANDS_AND_CONTROLLERS_TRACKING_PAUSE_INFO_META"/> + + <command name="xrResumeSimultaneousHandsAndControllersTrackingMETA"/> + <command name="xrPauseSimultaneousHandsAndControllersTrackingMETA"/> + </require> + </extension> + + <extension name="XR_META_extension_534" number="534" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_534_SPEC_VERSION"/> + <enum value=""XR_META_extension_534"" name="XR_META_extension_534_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_535" number="535" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_535_SPEC_VERSION"/> + <enum value=""XR_META_extension_535"" name="XR_META_extension_535_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_536" number="536" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_536_SPEC_VERSION"/> + <enum value=""XR_META_extension_536"" name="XR_META_extension_536_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_537" number="537" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_537_SPEC_VERSION"/> + <enum value=""XR_META_extension_537"" name="XR_META_extension_537_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_538" number="538" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_538_SPEC_VERSION"/> + <enum value=""XR_META_extension_538"" name="XR_META_extension_538_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_539" number="539" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_539_SPEC_VERSION"/> + <enum value=""XR_META_extension_539"" name="XR_META_extension_539_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_540" number="540" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_540_SPEC_VERSION"/> + <enum value=""XR_META_extension_540"" name="XR_META_extension_540_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_541" number="541" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_541_SPEC_VERSION"/> + <enum value=""XR_META_extension_541"" name="XR_META_extension_541_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_face_tracking_visemes" number="542" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_FB_face_tracking2"> + <require> + <enum value="1" name="XR_META_face_tracking_visemes_SPEC_VERSION"/> + <enum value=""XR_META_face_tracking_visemes"" name="XR_META_FACE_TRACKING_VISEMES_EXTENSION_NAME"/> + + <type name="XrFaceTrackingVisemeMETA"/> + + <enum value="15" name="XR_FACE_TRACKING_VISEME_COUNT_META"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_FACE_TRACKING_VISEMES_META"/> + <type name="XrFaceTrackingVisemesMETA"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SYSTEM_FACE_TRACKING_VISEMES_PROPERTIES_META"/> + <type name="XrSystemFaceTrackingVisemesPropertiesMETA"/> + </require> + </extension> + + <extension name="XR_META_extension_543" number="543" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_543_SPEC_VERSION"/> + <enum value=""XR_META_extension_543"" name="XR_META_extension_543_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_544" number="544" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_544_SPEC_VERSION"/> + <enum value=""XR_META_extension_544"" name="XR_META_extension_544_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_545" number="545" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_545_SPEC_VERSION"/> + <enum value=""XR_META_extension_545"" name="XR_META_extension_545_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_546" number="546" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_546_SPEC_VERSION"/> + <enum value=""XR_META_extension_546"" name="XR_META_extension_546_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_547" number="547" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_547_SPEC_VERSION"/> + <enum value=""XR_META_extension_547"" name="XR_META_extension_547_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_548" number="548" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_548_SPEC_VERSION"/> + <enum value=""XR_META_extension_548"" name="XR_META_extension_548_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_549" number="549" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_549_SPEC_VERSION"/> + <enum value=""XR_META_extension_549"" name="XR_META_extension_549_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_550" number="550" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_550_SPEC_VERSION"/> + <enum value=""XR_META_extension_550"" name="XR_META_extension_550_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_551" number="551" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_551_SPEC_VERSION"/> + <enum value=""XR_META_extension_551"" name="XR_META_extension_551_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_552" number="552" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_552_SPEC_VERSION"/> + <enum value=""XR_META_extension_552"" name="XR_META_extension_552_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_spatial_entity_semantic_label" number="553" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_spatial_entity_semantic_label_SPEC_VERSION"/> + <enum value=""XR_META_spatial_entity_semantic_label"" name="XR_META_SPATIAL_ENTITY_SEMANTIC_LABEL_EXTENSION_NAME"/> + + <type name="XrSemanticLabelMETA"/> + </require> + </extension> + + <extension name="XR_META_spatial_entity_room_mesh" number="554" type="instance" depends="XR_VERSION_1_0+XR_FB_spatial_entity+XR_META_spatial_entity_semantic_label" supported="openxr"> + <require> + <enum value="1" name="XR_META_spatial_entity_room_mesh_SPEC_VERSION"/> + <enum value=""XR_META_spatial_entity_room_mesh"" name="XR_META_SPATIAL_ENTITY_ROOM_MESH_EXTENSION_NAME"/> + + <enum offset="0" extends="XrSpaceComponentTypeFB" name="XR_SPACE_COMPONENT_TYPE_ROOM_MESH_META" comment="Room mesh component."/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_ROOM_MESH_FACE_INDICES_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPACE_ROOM_MESH_GET_INFO_META"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_ROOM_MESH_META"/> + + <type name="XrRoomMeshFaceMETA"/> + <type name="XrRoomMeshFaceIndicesMETA"/> + <type name="XrSpaceRoomMeshGetInfoMETA"/> + <type name="XrRoomMeshMETA"/> + + <command name="xrGetSpaceRoomMeshMETA"/> + <command name="xrGetSpaceRoomMeshFaceIndicesMETA"/> + </require> + </extension> + + <extension name="XR_EXT_composition_layer_inverted_alpha" number="555" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_EXT_composition_layer_inverted_alpha_SPEC_VERSION"/> + <enum value=""XR_EXT_composition_layer_inverted_alpha"" name="XR_EXT_COMPOSITION_LAYER_INVERTED_ALPHA_EXTENSION_NAME"/> + <enum bitpos="3" extends="XrCompositionLayerFlagBits" name="XR_COMPOSITION_LAYER_INVERTED_ALPHA_BIT_EXT" comment="Indicates that the texture alpha channel stores transparency instead of opacity, and is to be inverted before layer blending."/> + <!-- Addition to core bitmask from EXT approved by WG 14-March-2024 --> + </require> + </extension> + + <extension name="XR_META_extension_556" number="556" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_556_SPEC_VERSION"/> + <enum value=""XR_META_extension_556"" name="XR_META_extension_556_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_557" number="557" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_557_SPEC_VERSION"/> + <enum value=""XR_META_extension_557"" name="XR_META_extension_557_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_558" number="558" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_558_SPEC_VERSION"/> + <enum value=""XR_META_extension_558"" name="XR_META_extension_558_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_559" number="559" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_559_SPEC_VERSION"/> + <enum value=""XR_META_extension_559"" name="XR_META_extension_559_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_560" number="560" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_560_SPEC_VERSION"/> + <enum value=""XR_META_extension_560"" name="XR_META_extension_560_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_561" number="561" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_561_SPEC_VERSION"/> + <enum value=""XR_META_extension_561"" name="XR_META_extension_561_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_562" number="562" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_562_SPEC_VERSION"/> + <enum value=""XR_META_extension_562"" name="XR_META_extension_562_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_563" number="563" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_563_SPEC_VERSION"/> + <enum value=""XR_META_extension_563"" name="XR_META_extension_563_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_564" number="564" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_564_SPEC_VERSION"/> + <enum value=""XR_META_extension_564"" name="XR_META_extension_564_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_565" number="565" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_565_SPEC_VERSION"/> + <enum value=""XR_META_extension_565"" name="XR_META_extension_565_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_566" number="566" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_566_SPEC_VERSION"/> + <enum value=""XR_META_extension_566"" name="XR_META_extension_566_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_567" number="567" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_567_SPEC_VERSION"/> + <enum value=""XR_META_extension_567"" name="XR_META_extension_567_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_568" number="568" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_568_SPEC_VERSION"/> + <enum value=""XR_META_extension_568"" name="XR_META_extension_568_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_569" number="569" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_569_SPEC_VERSION"/> + <enum value=""XR_META_extension_569"" name="XR_META_extension_569_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_570" number="570" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_570_SPEC_VERSION"/> + <enum value=""XR_META_extension_570"" name="XR_META_extension_570_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_571" number="571" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_571_SPEC_VERSION"/> + <enum value=""XR_META_extension_571"" name="XR_META_extension_571_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_colocation_discovery" number="572" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_colocation_discovery_SPEC_VERSION"/> + <enum value=""XR_META_colocation_discovery"" name="XR_META_COLOCATION_DISCOVERY_EXTENSION_NAME"/> + + <enum value="1024" name="XR_MAX_COLOCATION_DISCOVERY_BUFFER_SIZE_META"/> + + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_COLOCATION_DISCOVERY_NETWORK_FAILED_META" comment="The network request failed."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_COLOCATION_DISCOVERY_NO_DISCOVERY_METHOD_META" comment="The runtime does not have any methods available to perform discovery."/> + <enum offset="3" extends="XrResult" name="XR_COLOCATION_DISCOVERY_ALREADY_ADVERTISING_META" comment="Colocation advertisement has already been enabled"/> + <enum offset="4" extends="XrResult" name="XR_COLOCATION_DISCOVERY_ALREADY_DISCOVERING_META" comment="Colocation discovery has already been enabled"/> + + <enum offset="10" extends="XrStructureType" name="XR_TYPE_COLOCATION_DISCOVERY_START_INFO_META"/> + <enum offset="11" extends="XrStructureType" name="XR_TYPE_COLOCATION_DISCOVERY_STOP_INFO_META"/> + <enum offset="12" extends="XrStructureType" name="XR_TYPE_COLOCATION_ADVERTISEMENT_START_INFO_META"/> + <enum offset="13" extends="XrStructureType" name="XR_TYPE_COLOCATION_ADVERTISEMENT_STOP_INFO_META"/> + <enum offset="20" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_START_COLOCATION_ADVERTISEMENT_COMPLETE_META"/> + <enum offset="21" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_STOP_COLOCATION_ADVERTISEMENT_COMPLETE_META"/> + <enum offset="22" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_COLOCATION_ADVERTISEMENT_COMPLETE_META"/> + <enum offset="23" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_START_COLOCATION_DISCOVERY_COMPLETE_META"/> + <enum offset="24" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_COLOCATION_DISCOVERY_RESULT_META"/> + <enum offset="25" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_COLOCATION_DISCOVERY_COMPLETE_META"/> + <enum offset="26" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_STOP_COLOCATION_DISCOVERY_COMPLETE_META"/> + <enum offset="30" extends="XrStructureType" name="XR_TYPE_SYSTEM_COLOCATION_DISCOVERY_PROPERTIES_META"/> + + <type name="XrColocationDiscoveryStartInfoMETA"/> + <type name="XrColocationDiscoveryStopInfoMETA"/> + <type name="XrColocationAdvertisementStartInfoMETA"/> + <type name="XrColocationAdvertisementStopInfoMETA"/> + + <type name="XrEventDataStartColocationAdvertisementCompleteMETA"/> + <type name="XrEventDataStopColocationAdvertisementCompleteMETA"/> + <type name="XrEventDataColocationAdvertisementCompleteMETA"/> + <type name="XrEventDataStartColocationDiscoveryCompleteMETA"/> + <type name="XrEventDataColocationDiscoveryResultMETA"/> + <type name="XrEventDataColocationDiscoveryCompleteMETA"/> + <type name="XrEventDataStopColocationDiscoveryCompleteMETA"/> + + <type name="XrSystemColocationDiscoveryPropertiesMETA"/> + + <command name="xrStartColocationDiscoveryMETA"/> + <command name="xrStopColocationDiscoveryMETA"/> + <command name="xrStartColocationAdvertisementMETA"/> + <command name="xrStopColocationAdvertisementMETA"/> + </require> + </extension> + + <extension name="XR_META_spatial_entity_group_sharing" number="573" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_spatial_entity_group_sharing_SPEC_VERSION"/> + <enum value=""XR_META_spatial_entity_group_sharing"" name="XR_META_SPATIAL_ENTITY_GROUP_SHARING_EXTENSION_NAME"/> + + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_SPACE_GROUP_NOT_FOUND_META" comment="The group UUID was not found within the runtime"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SHARE_SPACES_RECIPIENT_GROUPS_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPACE_GROUP_UUID_FILTER_INFO_META"/> + <enum offset="100" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPATIAL_ENTITY_GROUP_SHARING_PROPERTIES_META"/> + + <type name="XrSystemSpatialEntityGroupSharingPropertiesMETA"/> + </require> + <require depends="XR_META_spatial_entity_sharing"> + <type name="XrShareSpacesRecipientGroupsMETA"/> + </require> + <require depends="XR_FB_spatial_entity_query"> + <type name="XrSpaceGroupUuidFilterInfoMETA"/> + </require> + </extension> + + <extension name="XR_META_extension_574" number="574" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_574_SPEC_VERSION"/> + <enum value=""XR_META_extension_574"" name="XR_META_extension_574_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_575" number="575" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_575_SPEC_VERSION"/> + <enum value=""XR_META_extension_575"" name="XR_META_extension_575_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_576" number="576" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_576_SPEC_VERSION"/> + <enum value=""XR_META_extension_576"" name="XR_META_extension_576_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_577" number="577" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_577_SPEC_VERSION"/> + <enum value=""XR_META_extension_577"" name="XR_META_extension_577_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_578" number="578" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_578_SPEC_VERSION"/> + <enum value=""XR_META_extension_578"" name="XR_META_extension_578_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_579" number="579" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_579_SPEC_VERSION"/> + <enum value=""XR_META_extension_579"" name="XR_META_extension_579_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_580" number="580" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_580_SPEC_VERSION"/> + <enum value=""XR_META_extension_580"" name="XR_META_extension_580_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_581" number="581" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_581_SPEC_VERSION"/> + <enum value=""XR_META_extension_581"" name="XR_META_extension_581_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_582" number="582" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_582_SPEC_VERSION"/> + <enum value=""XR_META_extension_582"" name="XR_META_extension_582_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_583" number="583" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_583_SPEC_VERSION"/> + <enum value=""XR_META_extension_583"" name="XR_META_extension_583_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_584" number="584" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_584_SPEC_VERSION"/> + <enum value=""XR_META_extension_584"" name="XR_META_extension_584_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_585" number="585" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_585_SPEC_VERSION"/> + <enum value=""XR_META_extension_585"" name="XR_META_extension_585_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_586" number="586" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_586_SPEC_VERSION"/> + <enum value=""XR_META_extension_586"" name="XR_META_extension_586_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_587" number="587" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_587_SPEC_VERSION"/> + <enum value=""XR_META_extension_587"" name="XR_META_extension_587_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_588" number="588" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_588_SPEC_VERSION"/> + <enum value=""XR_META_extension_588"" name="XR_META_extension_588_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_589" number="589" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_589_SPEC_VERSION"/> + <enum value=""XR_META_extension_589"" name="XR_META_extension_589_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_590" number="590" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_590_SPEC_VERSION"/> + <enum value=""XR_META_extension_590"" name="XR_META_extension_590_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_591" number="591" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_591_SPEC_VERSION"/> + <enum value=""XR_META_extension_591"" name="XR_META_extension_591_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_592" number="592" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_592_SPEC_VERSION"/> + <enum value=""XR_META_extension_592"" name="XR_META_extension_592_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_environment_raycast" depends="XR_EXT_future" number="593" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_environment_raycast_SPEC_VERSION"/> + <enum value=""XR_META_environment_raycast"" name="XR_META_ENVIRONMENT_RAYCAST_EXTENSION_NAME"/> + + <type name="XrEnvironmentRaycasterMETA"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_ENVIRONMENT_RAYCASTER_META" comment="XrEnvironmentRaycasterMETA"/> + + <type name="XrSystemEnvironmentRaycastPropertiesMETA"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_ENVIRONMENT_RAYCAST_PROPERTIES_META"/> + + <type name="XrEnvironmentRaycasterCreateInfoMETA"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_RAYCASTER_CREATE_INFO_META"/> + + <type name="XrEnvironmentRaycasterCreateCompletionMETA"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_RAYCASTER_CREATE_COMPLETION_META"/> + + <type name="XrEnvironmentRaycastFilterBaseHeaderMETA"/> + + <type name="XrEnvironmentRaycastHitGetInfoMETA"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_RAYCAST_HIT_GET_INFO_META"/> + + <type name="XrEnvironmentRaycastHitMETA"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_RAYCAST_HIT_META"/> + + <type name="XrEnvironmentRaycastFilterDistanceMETA"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_RAYCAST_FILTER_DISTANCE_META"/> + + <type name="XrEnvironmentRaycastHitStatusMETA"/> + + <command name="xrCreateEnvironmentRaycasterAsyncMETA"/> + <command name="xrCreateEnvironmentRaycasterCompleteMETA"/> + <command name="xrDestroyEnvironmentRaycasterMETA"/> + <command name="xrPerformEnvironmentRaycastMETA"/> + </require> + </extension> + + <extension name="XR_META_extension_594" number="594" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_594_SPEC_VERSION"/> + <enum value=""XR_META_extension_594"" name="XR_META_extension_594_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_595" number="595" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_595_SPEC_VERSION"/> + <enum value=""XR_META_extension_595"" name="XR_META_extension_595_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_596" number="596" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_596_SPEC_VERSION"/> + <enum value=""XR_META_extension_596"" name="XR_META_extension_596_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_597" number="597" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_597_SPEC_VERSION"/> + <enum value=""XR_META_extension_597"" name="XR_META_extension_597_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_598" number="598" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_598_SPEC_VERSION"/> + <enum value=""XR_META_extension_598"" name="XR_META_extension_598_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_599" number="599" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_599_SPEC_VERSION"/> + <enum value=""XR_META_extension_599"" name="XR_META_extension_599_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_600" number="600" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_600_SPEC_VERSION"/> + <enum value=""XR_META_extension_600"" name="XR_META_extension_600_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_601" number="601" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_601_SPEC_VERSION"/> + <enum value=""XR_META_extension_601"" name="XR_META_extension_601_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_602" number="602" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_602_SPEC_VERSION"/> + <enum value=""XR_META_extension_602"" name="XR_META_extension_602_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_603" number="603" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_603_SPEC_VERSION"/> + <enum value=""XR_META_extension_603"" name="XR_META_extension_603_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_604" number="604" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_604_SPEC_VERSION"/> + <enum value=""XR_META_extension_604"" name="XR_META_extension_604_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_605" number="605" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_605_SPEC_VERSION"/> + <enum value=""XR_META_extension_605"" name="XR_META_extension_605_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_606" number="606" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_606_SPEC_VERSION"/> + <enum value=""XR_META_extension_606"" name="XR_META_extension_606_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_607" number="607" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_607_SPEC_VERSION"/> + <enum value=""XR_META_extension_607"" name="XR_META_extension_607_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_608" number="608" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_608_SPEC_VERSION"/> + <enum value=""XR_META_extension_608"" name="XR_META_extension_608_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_609" number="609" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_609_SPEC_VERSION"/> + <enum value=""XR_META_extension_609"" name="XR_META_extension_609_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_tile_properties_hint" number="610" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_tile_properties_hint_SPEC_VERSION"/> + <enum value=""XR_META_tile_properties_hint"" name="XR_META_TILE_PROPERTIES_HINT_EXTENSION_NAME"/> + + <type name="XrExtent3DiMETA"/> + <type name="XrTilePropertiesMETA"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_TILE_PROPERTIES_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_TILE_PROPERTIES_HINT_META"/> + <type name="XrTilePropertiesHintMETA"/> + <command name="xrSetTilePropertiesHintMETA"/> + </require> + </extension> + + <extension name="XR_META_extension_611" number="611" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_611_SPEC_VERSION"/> + <enum value=""XR_META_extension_611"" name="XR_META_extension_611_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_612" number="612" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_612_SPEC_VERSION"/> + <enum value=""XR_META_extension_612"" name="XR_META_extension_612_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_613" number="613" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_613_SPEC_VERSION"/> + <enum value=""XR_META_extension_613"" name="XR_META_extension_613_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_614" number="614" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_614_SPEC_VERSION"/> + <enum value=""XR_META_extension_614"" name="XR_META_extension_614_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_615" number="615" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_615_SPEC_VERSION"/> + <enum value=""XR_META_extension_615"" name="XR_META_extension_615_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_616" number="616" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_616_SPEC_VERSION"/> + <enum value=""XR_META_extension_616"" name="XR_META_extension_616_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_617" number="617" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_617_SPEC_VERSION"/> + <enum value=""XR_META_extension_617"" name="XR_META_extension_617_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_618" number="618" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_618_SPEC_VERSION"/> + <enum value=""XR_META_extension_618"" name="XR_META_extension_618_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_619" number="619" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_619_SPEC_VERSION"/> + <enum value=""XR_META_extension_619"" name="XR_META_extension_619_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_620" number="620" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_620_SPEC_VERSION"/> + <enum value=""XR_META_extension_620"" name="XR_META_extension_620_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_621" number="621" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_621_SPEC_VERSION"/> + <enum value=""XR_META_extension_621"" name="XR_META_extension_621_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_622" number="622" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_622_SPEC_VERSION"/> + <enum value=""XR_META_extension_622"" name="XR_META_extension_622_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_623" number="623" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_623_SPEC_VERSION"/> + <enum value=""XR_META_extension_623"" name="XR_META_extension_623_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_624" number="624" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_624_SPEC_VERSION"/> + <enum value=""XR_META_extension_624"" name="XR_META_extension_624_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_625" number="625" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_625_SPEC_VERSION"/> + <enum value=""XR_META_extension_625"" name="XR_META_extension_625_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_626" number="626" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_626_SPEC_VERSION"/> + <enum value=""XR_META_extension_626"" name="XR_META_extension_626_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_627" number="627" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_627_SPEC_VERSION"/> + <enum value=""XR_META_extension_627"" name="XR_META_extension_627_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_628" number="628" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_628_SPEC_VERSION"/> + <enum value=""XR_META_extension_628"" name="XR_META_extension_628_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_629" number="629" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_629_SPEC_VERSION"/> + <enum value=""XR_META_extension_629"" name="XR_META_extension_629_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_630" number="630" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_630_SPEC_VERSION"/> + <enum value=""XR_META_extension_630"" name="XR_META_extension_630_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_631" number="631" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_631_SPEC_VERSION"/> + <enum value=""XR_META_extension_631"" name="XR_META_extension_631_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_632" number="632" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_632_SPEC_VERSION"/> + <enum value=""XR_META_extension_632"" name="XR_META_extension_632_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_633" number="633" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_633_SPEC_VERSION"/> + <enum value=""XR_META_extension_633"" name="XR_META_extension_633_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_634" number="634" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_634_SPEC_VERSION"/> + <enum value=""XR_META_extension_634"" name="XR_META_extension_634_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_635" number="635" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_635_SPEC_VERSION"/> + <enum value=""XR_META_extension_635"" name="XR_META_extension_635_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_636" number="636" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_636_SPEC_VERSION"/> + <enum value=""XR_META_extension_636"" name="XR_META_extension_636_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_637" number="637" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_637_SPEC_VERSION"/> + <enum value=""XR_META_extension_637"" name="XR_META_extension_637_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_638" number="638" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_638_SPEC_VERSION"/> + <enum value=""XR_META_extension_638"" name="XR_META_extension_638_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_639" number="639" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_639_SPEC_VERSION"/> + <enum value=""XR_META_extension_639"" name="XR_META_extension_639_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_640" number="640" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_640_SPEC_VERSION"/> + <enum value=""XR_META_extension_640"" name="XR_META_extension_640_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_641" number="641" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_641_SPEC_VERSION"/> + <enum value=""XR_META_extension_641"" name="XR_META_extension_641_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_642" number="642" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_642_SPEC_VERSION"/> + <enum value=""XR_META_extension_642"" name="XR_META_extension_642_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_643" number="643" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_643_SPEC_VERSION"/> + <enum value=""XR_META_extension_643"" name="XR_META_extension_643_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_644" number="644" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_644_SPEC_VERSION"/> + <enum value=""XR_META_extension_644"" name="XR_META_extension_644_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_645" number="645" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_645_SPEC_VERSION"/> + <enum value=""XR_META_extension_645"" name="XR_META_extension_645_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_646" number="646" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_646_SPEC_VERSION"/> + <enum value=""XR_META_extension_646"" name="XR_META_extension_646_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_647" number="647" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_647_SPEC_VERSION"/> + <enum value=""XR_META_extension_647"" name="XR_META_extension_647_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_648" number="648" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_648_SPEC_VERSION"/> + <enum value=""XR_META_extension_648"" name="XR_META_extension_648_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_649" number="649" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_649_SPEC_VERSION"/> + <enum value=""XR_META_extension_649"" name="XR_META_extension_649_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_650" number="650" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_650_SPEC_VERSION"/> + <enum value=""XR_META_extension_650"" name="XR_META_extension_650_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_651" number="651" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_651_SPEC_VERSION"/> + <enum value=""XR_META_extension_651"" name="XR_META_extension_651_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_652" number="652" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_652_SPEC_VERSION"/> + <enum value=""XR_META_extension_652"" name="XR_META_extension_652_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_653" number="653" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_653_SPEC_VERSION"/> + <enum value=""XR_META_extension_653"" name="XR_META_extension_653_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_654" number="654" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_654_SPEC_VERSION"/> + <enum value=""XR_META_extension_654"" name="XR_META_extension_654_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_655" number="655" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_655_SPEC_VERSION"/> + <enum value=""XR_META_extension_655"" name="XR_META_extension_655_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_656" number="656" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_656_SPEC_VERSION"/> + <enum value=""XR_META_extension_656"" name="XR_META_extension_656_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_657" number="657" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_657_SPEC_VERSION"/> + <enum value=""XR_META_extension_657"" name="XR_META_extension_657_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_658" number="658" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_658_SPEC_VERSION"/> + <enum value=""XR_META_extension_658"" name="XR_META_extension_658_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_659" number="659" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_659_SPEC_VERSION"/> + <enum value=""XR_META_extension_659"" name="XR_META_extension_659_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_660" number="660" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_660_SPEC_VERSION"/> + <enum value=""XR_META_extension_660"" name="XR_META_extension_660_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_661" number="661" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_661_SPEC_VERSION"/> + <enum value=""XR_META_extension_661"" name="XR_META_extension_661_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_662" number="662" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_662_SPEC_VERSION"/> + <enum value=""XR_META_extension_662"" name="XR_META_extension_662_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_663" number="663" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_663_SPEC_VERSION"/> + <enum value=""XR_META_extension_663"" name="XR_META_extension_663_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_664" number="664" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_664_SPEC_VERSION"/> + <enum value=""XR_META_extension_664"" name="XR_META_extension_664_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_665" number="665" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_665_SPEC_VERSION"/> + <enum value=""XR_META_extension_665"" name="XR_META_extension_665_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_666" number="666" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_666_SPEC_VERSION"/> + <enum value=""XR_META_extension_666"" name="XR_META_extension_666_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_667" number="667" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_667_SPEC_VERSION"/> + <enum value=""XR_META_extension_667"" name="XR_META_extension_667_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_668" number="668" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_668_SPEC_VERSION"/> + <enum value=""XR_META_extension_668"" name="XR_META_extension_668_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_669" number="669" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_669_SPEC_VERSION"/> + <enum value=""XR_META_extension_669"" name="XR_META_extension_669_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_670" number="670" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_670_SPEC_VERSION"/> + <enum value=""XR_META_extension_670"" name="XR_META_extension_670_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_671" number="671" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_671_SPEC_VERSION"/> + <enum value=""XR_META_extension_671"" name="XR_META_extension_671_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_672" number="672" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_672_SPEC_VERSION"/> + <enum value=""XR_META_extension_672"" name="XR_META_extension_672_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_673" number="673" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_673_SPEC_VERSION"/> + <enum value=""XR_META_extension_673"" name="XR_META_extension_673_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_674" number="674" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_674_SPEC_VERSION"/> + <enum value=""XR_META_extension_674"" name="XR_META_extension_674_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_675" number="675" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_675_SPEC_VERSION"/> + <enum value=""XR_META_extension_675"" name="XR_META_extension_675_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_676" number="676" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_676_SPEC_VERSION"/> + <enum value=""XR_META_extension_676"" name="XR_META_extension_676_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_677" number="677" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_677_SPEC_VERSION"/> + <enum value=""XR_META_extension_677"" name="XR_META_extension_677_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_678" number="678" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_678_SPEC_VERSION"/> + <enum value=""XR_META_extension_678"" name="XR_META_extension_678_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_679" number="679" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_679_SPEC_VERSION"/> + <enum value=""XR_META_extension_679"" name="XR_META_extension_679_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_680" number="680" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_680_SPEC_VERSION"/> + <enum value=""XR_META_extension_680"" name="XR_META_extension_680_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_681" number="681" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_681_SPEC_VERSION"/> + <enum value=""XR_META_extension_681"" name="XR_META_extension_681_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_682" number="682" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_682_SPEC_VERSION"/> + <enum value=""XR_META_extension_682"" name="XR_META_extension_682_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_683" number="683" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_683_SPEC_VERSION"/> + <enum value=""XR_META_extension_683"" name="XR_META_extension_683_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_684" number="684" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_684_SPEC_VERSION"/> + <enum value=""XR_META_extension_684"" name="XR_META_extension_684_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_685" number="685" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_685_SPEC_VERSION"/> + <enum value=""XR_META_extension_685"" name="XR_META_extension_685_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_686" number="686" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_686_SPEC_VERSION"/> + <enum value=""XR_META_extension_686"" name="XR_META_extension_686_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_687" number="687" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_687_SPEC_VERSION"/> + <enum value=""XR_META_extension_687"" name="XR_META_extension_687_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_688" number="688" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_688_SPEC_VERSION"/> + <enum value=""XR_META_extension_688"" name="XR_META_extension_688_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_689" number="689" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_689_SPEC_VERSION"/> + <enum value=""XR_META_extension_689"" name="XR_META_extension_689_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_690" number="690" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_690_SPEC_VERSION"/> + <enum value=""XR_META_extension_690"" name="XR_META_extension_690_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_691" number="691" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_691_SPEC_VERSION"/> + <enum value=""XR_META_extension_691"" name="XR_META_extension_691_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_692" number="692" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_692_SPEC_VERSION"/> + <enum value=""XR_META_extension_692"" name="XR_META_extension_692_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_693" number="693" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_693_SPEC_VERSION"/> + <enum value=""XR_META_extension_693"" name="XR_META_extension_693_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_hand_tracking_unextrapolated_poses" number="694" depends="XR_VERSION_1_0+XR_EXT_hand_tracking" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_hand_tracking_unextrapolated_poses_SPEC_VERSION"/> + <enum value=""XR_META_hand_tracking_unextrapolated_poses"" name="XR_META_HAND_TRACKING_UNEXTRAPOLATED_POSES_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_HAND_TRACKING_UNEXTRAPOLATED_POSES_REQUEST_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_HAND_TRACKING_UNEXTRAPOLATED_POSES_META"/> + + <type name="XrHandTrackingUnextrapolatedPosesRequestMETA"/> + <type name="XrHandTrackingUnextrapolatedPosesMETA"/> + </require> + </extension> + + <extension name="XR_META_hand_tracking_frequency_hint" number="695" depends="XR_VERSION_1_0+XR_EXT_hand_tracking" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_hand_tracking_frequency_hint_SPEC_VERSION"/> + <enum value=""XR_META_hand_tracking_frequency_hint"" name="XR_META_HAND_TRACKING_FREQUENCY_HINT_EXTENSION_NAME"/> + + <type name="XrHandTrackingFrequencyHintMETA"/> + <command name="xrSetHandTrackingFrequencyHintMETA"/> + </require> + </extension> + + <extension name="XR_META_hand_tracking_wide_motion_mode2" number="696" depends="XR_VERSION_1_0+XR_EXT_hand_tracking+XR_EXT_hand_tracking_data_source" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_hand_tracking_wide_motion_mode2_SPEC_VERSION"/> + <enum value=""XR_META_hand_tracking_wide_motion_mode2"" name="XR_META_HAND_TRACKING_WIDE_MOTION_MODE2_EXTENSION_NAME"/> + + <enum offset="0" extends="XrHandTrackingDataSourceEXT" name="XR_HAND_TRACKING_DATA_SOURCE_UNOBSTRUCTED_WIDE_MOTION_META" comment="This data source value indicates that the hand tracking system should use wide motion mode inference to provide hand poses when the hands are not directly visible to the tracking cameras"/> + </require> + </extension> + + <extension name="XR_META_extension_697" number="697" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_697_SPEC_VERSION"/> + <enum value=""XR_META_extension_697"" name="XR_META_extension_697_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_698" number="698" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_698_SPEC_VERSION"/> + <enum value=""XR_META_extension_698"" name="XR_META_extension_698_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_699" number="699" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_699_SPEC_VERSION"/> + <enum value=""XR_META_extension_699"" name="XR_META_extension_699_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_KHR_egl_enable" number="700" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_KHR_egl_enable_SPEC_VERSION"/> + <enum value=""XR_KHR_egl_enable"" name="XR_KHR_EGL_ENABLE_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_light_estimation" number="701" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ANDROID_light_estimation_SPEC_VERSION"/> + <enum value=""XR_ANDROID_light_estimation"" name="XR_ANDROID_LIGHT_ESTIMATION_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_LIGHT_ESTIMATOR_CREATE_INFO_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_LIGHT_ESTIMATE_GET_INFO_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_LIGHT_ESTIMATE_ANDROID"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_DIRECTIONAL_LIGHT_ANDROID"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SPHERICAL_HARMONICS_ANDROID"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_AMBIENT_LIGHT_ANDROID"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_SYSTEM_LIGHT_ESTIMATION_PROPERTIES_ANDROID"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_LIGHT_ESTIMATOR_ANDROID" comment="XrLightEstimatorANDROID"/> + + <type name="XrSystemLightEstimationPropertiesANDROID"/> + <type name="XrLightEstimatorANDROID"/> + <type name="XrLightEstimatorCreateInfoANDROID"/> + <type name="XrLightEstimateGetInfoANDROID"/> + <type name="XrLightEstimateANDROID"/> + <type name="XrDirectionalLightANDROID"/> + <type name="XrAmbientLightANDROID"/> + <type name="XrSphericalHarmonicsANDROID"/> + + <type name="XrLightEstimateStateANDROID"/> + <type name="XrSphericalHarmonicsKindANDROID"/> + + <command name="xrCreateLightEstimatorANDROID"/> + <command name="xrDestroyLightEstimatorANDROID"/> + <command name="xrGetLightEstimateANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_anchor_sharing_export" number="702" type="instance" supported="openxr" protect="XR_USE_PLATFORM_ANDROID"> + <require> + <enum value="1" name="XR_ANDROID_anchor_sharing_export_SPEC_VERSION"/> + <enum value=""XR_ANDROID_anchor_sharing_export"" name="XR_ANDROID_ANCHOR_SHARING_EXPORT_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_ANCHOR_SHARING_INFO_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_ANCHOR_SHARING_TOKEN_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SYSTEM_ANCHOR_SHARING_EXPORT_PROPERTIES_ANDROID"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_ANCHOR_NOT_OWNED_BY_CALLER_ANDROID" comment="Operation not allowed because anchor is not owned by the slink:XrSession in which the function is being called."/> + + <type name="XrAnchorSharingInfoANDROID"/> + <type name="XrAnchorSharingTokenANDROID"/> + <type name="XrSystemAnchorSharingExportPropertiesANDROID"/> + + <command name="xrShareAnchorANDROID"/> + <command name="xrUnshareAnchorANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_703" number="703" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_703_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_703"" name="XR_ANDROID_EXTENSION_703_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_704" number="704" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_704_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_704"" name="XR_ANDROID_EXTENSION_704_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_mouse_interaction" number="705" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ANDROID_mouse_interaction_SPEC_VERSION"/> + <enum value=""XR_ANDROID_mouse_interaction"" name="XR_ANDROID_MOUSE_INTERACTION_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/android/mouse_interaction_android"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_706" number="706" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_706_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_706"" name="XR_ANDROID_EXTENSION_706_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_707" number="707" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_707_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_707"" name="XR_ANDROID_EXTENSION_707_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_trackables_marker" number="708" type="instance" supported="openxr" depends="XR_ANDROID_trackables" deprecatedby="XR_EXT_spatial_marker_tracking"> + <require> + <enum value="1" name="XR_ANDROID_trackables_marker_SPEC_VERSION"/> + <enum value=""XR_ANDROID_trackables_marker"" name="XR_ANDROID_TRACKABLES_MARKER_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_TRACKABLE_MARKER_CONFIGURATION_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_TRACKABLE_MARKER_ANDROID"/> + + <enum offset="0" extends="XrTrackableTypeANDROID" name="XR_TRACKABLE_TYPE_MARKER_ANDROID" comment="Indicates that the trackable is a marker."/> + + <type name="XrTrackableMarkerTrackingModeANDROID"/> + <type name="XrTrackableMarkerDictionaryANDROID"/> + + <type name="XrSystemMarkerTrackingPropertiesANDROID"/> + <type name="XrTrackableMarkerConfigurationANDROID"/> + <type name="XrTrackableMarkerDatabaseANDROID"/> + <type name="XrTrackableMarkerDatabaseEntryANDROID"/> + <type name="XrTrackableMarkerANDROID"/> + + <command name="xrGetTrackableMarkerANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_trackables_qr_code" number="709" type="instance" supported="openxr" depends="XR_ANDROID_trackables" deprecatedby="XR_EXT_spatial_marker_tracking"> + <require> + <enum value="1" name="XR_ANDROID_trackables_qr_code_SPEC_VERSION"/> + <enum value=""XR_ANDROID_trackables_qr_code"" name="XR_ANDROID_TRACKABLES_QR_CODE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_QR_CODE_TRACKING_PROPERTIES_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_TRACKABLE_QR_CODE_CONFIGURATION_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_TRACKABLE_QR_CODE_ANDROID"/> + + <enum offset="0" extends="XrTrackableTypeANDROID" name="XR_TRACKABLE_TYPE_QR_CODE_ANDROID" comment="Indicates that the trackable is a QR code."/> + + <type name="XrQrCodeTrackingModeANDROID"/> + + <type name="XrSystemQrCodeTrackingPropertiesANDROID"/> + <type name="XrTrackableQrCodeConfigurationANDROID"/> + <type name="XrTrackableQrCodeANDROID"/> + + <command name="xrGetTrackableQrCodeANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_trackables_image" number="710" type="instance" supported="openxr" depends="XR_EXT_future+XR_ANDROID_trackables"> + <require> + <enum value="1" name="XR_ANDROID_trackables_image_SPEC_VERSION"/> + <enum value=""XR_ANDROID_trackables_image"" name="XR_ANDROID_TRACKABLES_IMAGE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_IMAGE_TRACKING_PROPERTIES_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_TRACKABLE_IMAGE_DATABASE_ENTRY_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_TRACKABLE_IMAGE_DATABASE_CREATE_INFO_ANDROID"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_CREATE_TRACKABLE_IMAGE_DATABASE_COMPLETION_ANDROID"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_TRACKABLE_IMAGE_CONFIGURATION_ANDROID"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_TRACKABLE_IMAGE_ANDROID"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_IMAGE_TRACKING_LOST_ANDROID"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_TRACKABLE_IMAGE_DATABASE_ANDROID" comment="XrTrackableImageDatabaseANDROID"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_IMAGE_FORMAT_UNSUPPORTED_ANDROID" comment="Indicates that the input reference image format is not supported."/> + + <enum offset="0" extends="XrTrackableTypeANDROID" name="XR_TRACKABLE_TYPE_IMAGE_ANDROID" comment="Indicates that the trackable is an image."/> + + <type name="XrTrackableImageDatabaseANDROID"/> + + <type name="XrTrackableImageTrackingModeANDROID"/> + <type name="XrTrackableImageFormatANDROID"/> + + <type name="XrSystemImageTrackingPropertiesANDROID"/> + <type name="XrTrackableImageDatabaseEntryANDROID"/> + <type name="XrTrackableImageDatabaseCreateInfoANDROID"/> + <type name="XrCreateTrackableImageDatabaseCompletionANDROID"/> + <type name="XrTrackableImageConfigurationANDROID"/> + <type name="XrTrackableImageANDROID"/> + <type name="XrEventDataImageTrackingLostANDROID"/> + + <command name="xrCreateTrackableImageDatabaseAsyncANDROID"/> + <command name="xrCreateTrackableImageDatabaseCompleteANDROID"/> + <command name="xrDestroyTrackableImageDatabaseANDROID"/> + <command name="xrAddTrackableImageDatabaseANDROID"/> + <command name="xrRemoveTrackableImageDatabaseANDROID"/> + <command name="xrGetTrackableImageANDROID"/> + </require> + </extension> + + <extension name="XR_KHR_maintenance1" number="711" type="instance" supported="openxr" promotedto="XR_VERSION_1_1" ratified="openxr"> + <require> + <enum value="1" name="XR_KHR_maintenance1_SPEC_VERSION"/> + <enum value=""XR_KHR_maintenance1"" name="XR_KHR_MAINTENANCE1_EXTENSION_NAME"/> + + <!-- new structs --> + <type name="XrColor3fKHR"/> + <type name="XrExtent3DfKHR"/> + <type name="XrSpherefKHR"/> + <type name="XrBoxfKHR"/> + <type name="XrFrustumfKHR"/> + + + <!-- error codes --> + <enum extends="XrResult" name="XR_ERROR_EXTENSION_DEPENDENCY_NOT_ENABLED_KHR" alias="XR_ERROR_EXTENSION_DEPENDENCY_NOT_ENABLED"/> + <enum extends="XrResult" name="XR_ERROR_PERMISSION_INSUFFICIENT_KHR" alias="XR_ERROR_PERMISSION_INSUFFICIENT"/> + + </require> + + <!-- grip_surface --> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)"> + <extend interaction_profile_path="/interaction_profiles/khr/simple_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/google/daydream_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/htc/vive_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/microsoft/motion_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/oculus/go_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/oculus/touch_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/valve/index_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_MSFT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/microsoft/hand_interaction"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_HUAWEI_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/huawei/controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_HTC_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/htc/hand_interaction"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_HTC_vive_cosmos_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_cosmos_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_HTC_vive_focus3_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_focus3_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_HTCX_vive_tracker_interaction"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_tracker_htcx"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_EXT_samsung_odyssey_controller"> + <extend interaction_profile_path="/interaction_profiles/samsung/odyssey_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_EXT_hp_mixed_reality_controller"> + <extend interaction_profile_path="/interaction_profiles/hp/mixed_reality_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_ML_ml2_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/ml/ml2_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_FB_touch_controller_pro"> + <extend interaction_profile_path="/interaction_profiles/facebook/touch_controller_pro"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_META_touch_controller_plus"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_plus"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_BD_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_neo3_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico4_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_g3_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_OPPO_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/oppo/mr_controller_oppo"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_YVR_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/yvr/touch_controller_yvr"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_VARJO_xr4_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/varjo/xr-4_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/ext/hand_interaction_ext"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_LOGITECH_mx_ink_stylus_interaction"> + <extend interaction_profile_path="/interaction_profiles/logitech/mx_ink_stylus_logitech"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <!-- grip_surface --> + </extension> + + <extension name="XR_KHR_generic_controller" number="712" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="1" name="XR_KHR_generic_controller_SPEC_VERSION"/> + <enum value=""XR_KHR_generic_controller"" name="XR_KHR_GENERIC_CONTROLLER_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/khr/generic_controller"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/khr/generic_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/khr/generic_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/khr/generic_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_VARJO_extension_713" number="713" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VARJO_extension_713_SPEC_VERSION"/> + <enum value=""XR_VARJO_extension_713"" name="XR_VARJO_EXTENSION_713_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VARJO_extension_714" number="714" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VARJO_extension_714_SPEC_VERSION"/> + <enum value=""XR_VARJO_extension_714"" name="XR_VARJO_EXTENSION_714_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VARJO_extension_715" number="715" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VARJO_extension_715_SPEC_VERSION"/> + <enum value=""XR_VARJO_extension_715"" name="XR_VARJO_EXTENSION_715_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDX_extension_716" number="716" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDX_extension_716_SPEC_VERSION"/> + <enum value=""XR_ANDROIDX_extension_716"" name="XR_ANDROIDX_EXTENSION_716_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDX_extension_717" number="717" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDX_extension_717_SPEC_VERSION"/> + <enum value=""XR_ANDROIDX_extension_717"" name="XR_ANDROIDX_EXTENSION_717_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDX_extension_718" number="718" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDX_extension_718_SPEC_VERSION"/> + <enum value=""XR_ANDROIDX_extension_718"" name="XR_ANDROIDX_EXTENSION_718_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_scene_meshing" number="719" type="instance" supported="openxr"> + <require> + <enum value="3" name="XR_ANDROID_scene_meshing_SPEC_VERSION"/> + <enum value=""XR_ANDROID_scene_meshing"" name="XR_ANDROID_SCENE_MESHING_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_SCENE_MESHING_PROPERTIES_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SCENE_MESHING_TRACKER_CREATE_INFO_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SCENE_MESH_SNAPSHOT_CREATE_INFO_ANDROID"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SCENE_MESH_SNAPSHOT_CREATION_RESULT_ANDROID"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SCENE_SUBMESH_STATE_ANDROID"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_SCENE_SUBMESH_DATA_ANDROID"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SCENE_MESHING_TRACKER_ANDROID" comment="XrSceneMeshingTrackerANDROID"/> + <enum offset="1" extends="XrObjectType" name="XR_OBJECT_TYPE_SCENE_MESH_SNAPSHOT_ANDROID" comment="XrSceneMeshSnapshotANDROID"/> + + <type name="XrSceneMeshingTrackerANDROID"/> + <type name="XrSceneMeshSnapshotANDROID"/> + <type name="XrSystemSceneMeshingPropertiesANDROID"/> + <type name="XrSceneMeshingTrackerCreateInfoANDROID"/> + <type name="XrSceneMeshSnapshotCreateInfoANDROID"/> + <type name="XrSceneMeshSnapshotCreationResultANDROID"/> + <type name="XrSceneSubmeshStateANDROID"/> + <type name="XrSceneSubmeshDataANDROID"/> + <type name="XrSceneMeshSemanticLabelSetANDROID"/> + <type name="XrSceneMeshSemanticLabelANDROID"/> + <type name="XrSceneMeshTrackingStateANDROID"/> + + <command name="xrEnumerateSupportedSemanticLabelSetsANDROID"/> + <command name="xrCreateSceneMeshingTrackerANDROID"/> + <command name="xrDestroySceneMeshingTrackerANDROID"/> + <command name="xrCreateSceneMeshSnapshotANDROID"/> + <command name="xrDestroySceneMeshSnapshotANDROID"/> + <command name="xrGetAllSubmeshStatesANDROID"/> + <command name="xrGetSubmeshDataANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROIDX_extension_720" number="720" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDX_extension_720_SPEC_VERSION"/> + <enum value=""XR_ANDROIDX_extension_720"" name="XR_ANDROIDX_EXTENSION_720_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDX_extension_721" number="721" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDX_extension_721_SPEC_VERSION"/> + <enum value=""XR_ANDROIDX_extension_721"" name="XR_ANDROIDX_EXTENSION_721_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDX_extension_722" number="722" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDX_extension_722_SPEC_VERSION"/> + <enum value=""XR_ANDROIDX_extension_722"" name="XR_ANDROIDX_EXTENSION_722_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDX_extension_723" number="723" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDX_extension_723_SPEC_VERSION"/> + <enum value=""XR_ANDROIDX_extension_723"" name="XR_ANDROIDX_EXTENSION_723_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDX_extension_724" number="724" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDX_extension_724_SPEC_VERSION"/> + <enum value=""XR_ANDROIDX_extension_724"" name="XR_ANDROIDX_EXTENSION_724_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDX_extension_725" number="725" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDX_extension_725_SPEC_VERSION"/> + <enum value=""XR_ANDROIDX_extension_725"" name="XR_ANDROIDX_EXTENSION_725_EXTENSION_NAME"/> + </require> + </extension> + <extension name="XR_ANDROIDSYS_extension_726" number="726" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDSYS_extension_726_SPEC_VERSION"/> + <enum value=""XR_ANDROIDSYS_extension_726"" name="XR_ANDROIDSYS_EXTENSION_726_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDSYS_extension_727" number="727" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDSYS_extension_727_SPEC_VERSION"/> + <enum value=""XR_ANDROIDSYS_extension_727"" name="XR_ANDROIDSYS_EXTENSION_727_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDSYS_extension_728" number="728" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDSYS_extension_728_SPEC_VERSION"/> + <enum value=""XR_ANDROIDSYS_extension_728"" name="XR_ANDROIDSYS_EXTENSION_728_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDSYS_extension_729" number="729" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDSYS_extension_729_SPEC_VERSION"/> + <enum value=""XR_ANDROIDSYS_extension_729"" name="XR_ANDROIDSYS_EXTENSION_729_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDSYS_extension_730" number="730" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDSYS_extension_730_SPEC_VERSION"/> + <enum value=""XR_ANDROIDSYS_extension_730"" name="XR_ANDROIDSYS_EXTENSION_730_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDSYS_extension_731" number="731" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDSYS_extension_731_SPEC_VERSION"/> + <enum value=""XR_ANDROIDSYS_extension_731"" name="XR_ANDROIDSYS_EXTENSION_731_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDSYS_extension_732" number="732" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDSYS_extension_732_SPEC_VERSION"/> + <enum value=""XR_ANDROIDSYS_extension_732"" name="XR_ANDROIDSYS_EXTENSION_732_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDSYS_extension_733" number="733" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDSYS_extension_733_SPEC_VERSION"/> + <enum value=""XR_ANDROIDSYS_extension_733"" name="XR_ANDROIDSYS_EXTENSION_733_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDSYS_extension_734" number="734" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDSYS_extension_734_SPEC_VERSION"/> + <enum value=""XR_ANDROIDSYS_extension_734"" name="XR_ANDROIDSYS_EXTENSION_734_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDSYS_extension_735" number="735" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDSYS_extension_735_SPEC_VERSION"/> + <enum value=""XR_ANDROIDSYS_extension_735"" name="XR_ANDROIDSYS_EXTENSION_735_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LEIA_extension_736" number="736" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LEIA_extension_736_SPEC_VERSION"/> + <enum value=""XR_LEIA_extension_736"" name="XR_LEIA_EXTENSION_736_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LEIA_extension_737" number="737" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LEIA_extension_737_SPEC_VERSION"/> + <enum value=""XR_LEIA_extension_737"" name="XR_LEIA_EXTENSION_737_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LEIA_extension_738" number="738" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LEIA_extension_738_SPEC_VERSION"/> + <enum value=""XR_LEIA_extension_738"" name="XR_LEIA_EXTENSION_738_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_739" number="739" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_739_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_739"" name="XR_EXT_EXTENSION_739_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_740" number="740" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_740_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_740"" name="XR_EXT_EXTENSION_740_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_spatial_entity" number="741" type="instance" supported="openxr" depends="XR_EXT_future" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_spatial_entity_SPEC_VERSION"/> + <enum value=""XR_EXT_spatial_entity"" name="XR_EXT_SPATIAL_ENTITY_EXTENSION_NAME"/> + + <type name="XR_NULL_SPATIAL_ENTITY_ID_EXT"/> + <type name="XR_NULL_SPATIAL_BUFFER_ID_EXT"/> + + <type name="XrSpatialEntityIdEXT"/> + <type name="XrSpatialBufferIdEXT"/> + + <type name="XrSpatialEntityEXT"/> + <type name="XrSpatialContextEXT"/> + <type name="XrSpatialSnapshotEXT"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SPATIAL_ENTITY_EXT" comment="XrSpatialEntityEXT"/> + <enum offset="1" extends="XrObjectType" name="XR_OBJECT_TYPE_SPATIAL_CONTEXT_EXT" comment="XrSpatialContextEXT"/> + <enum offset="2" extends="XrObjectType" name="XR_OBJECT_TYPE_SPATIAL_SNAPSHOT_EXT" comment="XrSpatialSnapshotEXT"/> + + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT" comment="The specified spatial capability is not supported by the runtime or the system."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ENTITY_ID_INVALID_EXT" comment="The specified spatial entity id is invalid or an entity with that id does not exist in the environment."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT" comment="The specified spatial buffer id is invalid or does not exist in the spatial snapshot being used to query for the buffer data."/> + <enum offset="4" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_COMPONENT_UNSUPPORTED_FOR_CAPABILITY_EXT" comment="The specified spatial component is not supported by the runtime or the system for the given capability."/> + <enum offset="5" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT" comment="The specified spatial capability configuration is invalid."/> + <enum offset="6" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_COMPONENT_NOT_ENABLED_EXT" comment="The specified spatial component is not enabled for the spatial context."/> + + <type name="XrSpatialCapabilityEXT"/> + <type name="XrSpatialCapabilityFeatureEXT"/> + <type name="XrSpatialComponentTypeEXT"/> + <type name="XrSpatialEntityTrackingStateEXT"/> + <type name="XrSpatialBufferTypeEXT"/> + + <type name="XrSpatialCapabilityComponentTypesEXT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_CAPABILITY_COMPONENT_TYPES_EXT"/> + <type name="XrSpatialCapabilityConfigurationBaseHeaderEXT"/> + <type name="XrSpatialContextCreateInfoEXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_CONTEXT_CREATE_INFO_EXT"/> + <type name="XrCreateSpatialContextCompletionEXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_CREATE_SPATIAL_CONTEXT_COMPLETION_EXT"/> + <type name="XrSpatialDiscoverySnapshotCreateInfoEXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPATIAL_DISCOVERY_SNAPSHOT_CREATE_INFO_EXT"/> + <type name="XrCreateSpatialDiscoverySnapshotCompletionInfoEXT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_INFO_EXT"/> + <type name="XrCreateSpatialDiscoverySnapshotCompletionEXT"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_EXT"/> + <type name="XrSpatialComponentDataQueryConditionEXT"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_CONDITION_EXT"/> + <type name="XrSpatialComponentDataQueryResultEXT"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_RESULT_EXT"/> + <type name="XrSpatialBufferEXT"/> + <type name="XrSpatialBufferGetInfoEXT"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_SPATIAL_BUFFER_GET_INFO_EXT"/> + <type name="XrSpatialBounded2DDataEXT"/> + <type name="XrSpatialComponentBounded2DListEXT"/> + <enum offset="9" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_BOUNDED_2D_LIST_EXT"/> + <type name="XrSpatialComponentBounded3DListEXT"/> + <enum offset="10" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_BOUNDED_3D_LIST_EXT"/> + <type name="XrSpatialComponentParentListEXT"/> + <enum offset="11" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_PARENT_LIST_EXT"/> + <type name="XrSpatialMeshDataEXT"/> + <type name="XrSpatialComponentMesh3DListEXT"/> + <enum offset="12" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_MESH_3D_LIST_EXT"/> + <type name="XrSpatialEntityFromIdCreateInfoEXT"/> + <enum offset="13" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_FROM_ID_CREATE_INFO_EXT"/> + <type name="XrSpatialUpdateSnapshotCreateInfoEXT"/> + <enum offset="14" extends="XrStructureType" name="XR_TYPE_SPATIAL_UPDATE_SNAPSHOT_CREATE_INFO_EXT"/> + <type name="XrEventDataSpatialDiscoveryRecommendedEXT"/> + <enum offset="15" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT"/> + <type name="XrSpatialFilterTrackingStateEXT"/> + <enum offset="16" extends="XrStructureType" name="XR_TYPE_SPATIAL_FILTER_TRACKING_STATE_EXT"/> + + <command name="xrEnumerateSpatialCapabilitiesEXT"/> + <command name="xrEnumerateSpatialCapabilityComponentTypesEXT"/> + <command name="xrEnumerateSpatialCapabilityFeaturesEXT"/> + <command name="xrCreateSpatialContextAsyncEXT"/> + <command name="xrCreateSpatialContextCompleteEXT"/> + <command name="xrDestroySpatialContextEXT"/> + <command name="xrCreateSpatialDiscoverySnapshotAsyncEXT"/> + <command name="xrCreateSpatialDiscoverySnapshotCompleteEXT"/> + <command name="xrQuerySpatialComponentDataEXT"/> + <command name="xrDestroySpatialSnapshotEXT"/> + <command name="xrCreateSpatialEntityFromIdEXT"/> + <command name="xrDestroySpatialEntityEXT"/> + <command name="xrCreateSpatialUpdateSnapshotEXT"/> + <command name="xrGetSpatialBufferStringEXT"/> + <command name="xrGetSpatialBufferUint8EXT"/> + <command name="xrGetSpatialBufferUint16EXT"/> + <command name="xrGetSpatialBufferUint32EXT"/> + <command name="xrGetSpatialBufferFloatEXT"/> + <command name="xrGetSpatialBufferVector2fEXT"/> + <command name="xrGetSpatialBufferVector3fEXT"/> + + </require> + </extension> + + <extension name="XR_EXT_spatial_plane_tracking" number="742" type="instance" supported="openxr" depends="XR_EXT_spatial_entity" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_spatial_plane_tracking_SPEC_VERSION"/> + <enum value=""XR_EXT_spatial_plane_tracking"" name="XR_EXT_SPATIAL_PLANE_TRACKING_EXTENSION_NAME"/> + + <enum offset="0" extends="XrSpatialCapabilityEXT" name="XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT" comment="Plane tracking"/> + + <enum offset="0" extends="XrSpatialComponentTypeEXT" name="XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT" comment="Component that provides the plane alignment enum for a spatial entity. Corresponding list structure is slink:XrSpatialComponentPlaneAlignmentListEXT; Corresponding data structure is elink:XrSpatialPlaneAlignmentEXT"/> + <enum offset="1" extends="XrSpatialComponentTypeEXT" name="XR_SPATIAL_COMPONENT_TYPE_MESH_2D_EXT" comment="Component that provides a 2D mesh for a spatial entity. Corresponding list structure is slink:XrSpatialComponentMesh2DListEXT; Corresponding data structure is slink:XrSpatialMeshDataEXT"/> + <enum offset="2" extends="XrSpatialComponentTypeEXT" name="XR_SPATIAL_COMPONENT_TYPE_POLYGON_2D_EXT" comment="Component that provides a 2D boundary polygon for a spatial entity. Corresponding list structure is slink:XrSpatialComponentPolygon2DListEXT; Corresponding data structure is slink:XrSpatialPolygon2DDataEXT"/> + <enum offset="3" extends="XrSpatialComponentTypeEXT" name="XR_SPATIAL_COMPONENT_TYPE_PLANE_SEMANTIC_LABEL_EXT" comment="Component that provides a semantic label for a plane. Corresponding list structure is slink:XrSpatialComponentPlaneSemanticLabelListEXT; Corresponding data structure is elink:XrSpatialPlaneSemanticLabelEXT"/> + + <type name="XrSpatialPlaneAlignmentEXT"/> + <type name="XrSpatialPlaneSemanticLabelEXT"/> + + <type name="XrSpatialCapabilityConfigurationPlaneTrackingEXT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_PLANE_TRACKING_EXT"/> + <type name="XrSpatialComponentPlaneAlignmentListEXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_PLANE_ALIGNMENT_LIST_EXT"/> + <type name="XrSpatialComponentMesh2DListEXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_MESH_2D_LIST_EXT"/> + <type name="XrSpatialPolygon2DDataEXT"/> + <type name="XrSpatialComponentPolygon2DListEXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_POLYGON_2D_LIST_EXT"/> + <type name="XrSpatialComponentPlaneSemanticLabelListEXT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_PLANE_SEMANTIC_LABEL_LIST_EXT"/> + + </require> + </extension> + + <extension name="XR_EXT_stationary_reference_space" number="743" type="instance" depends="XR_VERSION_1_0+XR_EXT_uuid" supported="openxr"> + <require> + <enum value="1" name="XR_EXT_stationary_reference_space_SPEC_VERSION"/> + <enum value=""XR_EXT_stationary_reference_space"" name="XR_EXT_STATIONARY_REFERENCE_SPACE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrReferenceSpaceType" name="XR_REFERENCE_SPACE_TYPE_STATIONARY_EXT"/> + + <type name="XrStationaryReferenceSpaceGenerationIdGetInfoEXT"/> + <type name="XrStationaryReferenceSpaceGenerationIdResultEXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_STATIONARY_REFERENCE_SPACE_GENERATION_ID_GET_INFO_EXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_STATIONARY_REFERENCE_SPACE_GENERATION_ID_RESULT_EXT"/> + + <command name="xrGetStationaryReferenceSpaceGenerationIdEXT"/> + </require> + </extension> + + <extension name="XR_EXT_spatial_marker_tracking" number="744" type="instance" supported="openxr" depends="XR_EXT_spatial_entity" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_spatial_marker_tracking_SPEC_VERSION"/> + <enum value=""XR_EXT_spatial_marker_tracking"" name="XR_EXT_SPATIAL_MARKER_TRACKING_EXTENSION_NAME"/> + + <enum offset="0" extends="XrSpatialCapabilityEXT" name="XR_SPATIAL_CAPABILITY_MARKER_TRACKING_QR_CODE_EXT" comment="Capability to be able to detect and track QR codes."/> + <enum offset="1" extends="XrSpatialCapabilityEXT" name="XR_SPATIAL_CAPABILITY_MARKER_TRACKING_MICRO_QR_CODE_EXT" comment="Capability to be able to detect and track Micro QR codes."/> + <enum offset="2" extends="XrSpatialCapabilityEXT" name="XR_SPATIAL_CAPABILITY_MARKER_TRACKING_ARUCO_MARKER_EXT" comment="Capability to be able to detect and track Aruco Markers."/> + <enum offset="3" extends="XrSpatialCapabilityEXT" name="XR_SPATIAL_CAPABILITY_MARKER_TRACKING_APRIL_TAG_EXT" comment="Capability to be able to detect and track AprilTags."/> + + <enum offset="0" extends="XrSpatialComponentTypeEXT" name="XR_SPATIAL_COMPONENT_TYPE_MARKER_EXT" comment="A component describing the marker type, id and location. Corresponding list structure is slink:XrSpatialComponentMarkerListEXT; Corresponding data structure is slink:XrSpatialMarkerDataEXT"/> + + <enum offset="0" extends="XrSpatialCapabilityFeatureEXT" name="XR_SPATIAL_CAPABILITY_FEATURE_MARKER_TRACKING_FIXED_SIZE_MARKERS_EXT" comment="Capability feature to allow applications to specify the size for the markers. Corresponding config structure is slink:XrSpatialMarkerSizeEXT"/> + <enum offset="1" extends="XrSpatialCapabilityFeatureEXT" name="XR_SPATIAL_CAPABILITY_FEATURE_MARKER_TRACKING_STATIC_MARKERS_EXT" comment="Capability feature to allow applications to specify if markers are static. Corresponding config structure is slink:XrSpatialMarkerStaticOptimizationEXT"/> + + <!-- enums --> + <type name="XrSpatialMarkerArucoDictEXT"/> + <type name="XrSpatialMarkerAprilTagDictEXT"/> + + <!-- structs --> + <type name="XrSpatialCapabilityConfigurationQrCodeEXT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_QR_CODE_EXT"/> + <type name="XrSpatialCapabilityConfigurationMicroQrCodeEXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_MICRO_QR_CODE_EXT"/> + <type name="XrSpatialCapabilityConfigurationArucoMarkerEXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ARUCO_MARKER_EXT"/> + <type name="XrSpatialCapabilityConfigurationAprilTagEXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_APRIL_TAG_EXT"/> + <type name="XrSpatialMarkerSizeEXT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SPATIAL_MARKER_SIZE_EXT"/> + <type name="XrSpatialMarkerStaticOptimizationEXT"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_SPATIAL_MARKER_STATIC_OPTIMIZATION_EXT"/> + <type name="XrSpatialMarkerDataEXT"/> + <type name="XrSpatialComponentMarkerListEXT"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_MARKER_LIST_EXT"/> + </require> + </extension> + + <extension name="XR_EXT_extension_745" number="745" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_745_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_745"" name="XR_EXT_EXTENSION_745_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LOGITECH_mx_ink_stylus_interaction" number="746" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_LOGITECH_mx_ink_stylus_interaction_SPEC_VERSION"/> + <enum value=""XR_LOGITECH_mx_ink_stylus_interaction"" name="XR_LOGITECH_MX_INK_STYLUS_INTERACTION_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/logitech/mx_ink_stylus_logitech"/> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/logitech/mx_ink_stylus_logitech"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/logitech/mx_ink_stylus_logitech"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_BD_dynamic_object_tracking" number="747" depends="XR_BD_spatial_sensing" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_dynamic_object_tracking_SPEC_VERSION"/> + <enum value=""XR_BD_dynamic_object_tracking"" name="XR_BD_DYNAMIC_OBJECT_TRACKING_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_DYNAMIC_OBJECT_TRACKING_PROPERTIES_BD"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_DYNAMIC_OBJECT_BD"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_DYNAMIC_OBJECT_BD"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_DYNAMIC_OBJECT_DATA_BD"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SENSE_DATA_FILTER_DYNAMIC_OBJECT_TYPE_BD" comment="XrSenseDataFilterDynamicObjectTypeBD"/> + + <enum offset="0" extends="XrSenseDataProviderTypeBD" name="XR_SENSE_DATA_PROVIDER_TYPE_DYNAMIC_OBJECT_BD" comment="Capture dynamic object data."/> + + <enum offset="0" extends="XrSpatialEntityComponentTypeBD" name="XR_SPATIAL_ENTITY_COMPONENT_TYPE_DYNAMIC_OBJECT_BD" comment="The dynamic object component. Corresponds to component data structure slink:XrSpatialEntityComponentDataDynamicObjectBD."/> + + <type name="XrSystemDynamicObjectTrackingPropertiesBD"/> + <type name="XrSenseDataProviderCreateInfoDynamicObjectBD"/> + <type name="XrSpatialEntityComponentDataDynamicObjectBD"/> + <type name="XrDynamicObjectDataBD"/> + <type name="XrSenseDataFilterDynamicObjectTypeBD"/> + <type name="XrDynamicObjectTypeBD"/> + + </require> + </extension> + + <extension name="XR_BD_dynamic_object_keyboard" number="748" depends="XR_BD_dynamic_object_tracking" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_dynamic_object_keyboard_SPEC_VERSION"/> + <enum value=""XR_BD_dynamic_object_keyboard"" name="XR_BD_DYNAMIC_OBJECT_KEYBOARD_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_DYNAMIC_OBJECT_KEYBOARD_PROPERTIES_BD"/> + <enum offset="0" extends="XrDynamicObjectTypeBD" name="XR_DYNAMIC_OBJECT_TYPE_KEYBOARD_BD" comment="Represents a keyboard"/> + + <type name="XrSystemDynamicObjectKeyboardPropertiesBD"/> + + </require> + </extension> + + <extension name="XR_BD_dynamic_object_mouse" number="749" depends="XR_BD_dynamic_object_tracking" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_dynamic_object_mouse_SPEC_VERSION"/> + <enum value=""XR_BD_dynamic_object_mouse"" name="XR_BD_DYNAMIC_OBJECT_MOUSE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_DYNAMIC_OBJECT_MOUSE_PROPERTIES_BD"/> + <enum offset="0" extends="XrDynamicObjectTypeBD" name="XR_DYNAMIC_OBJECT_TYPE_MOUSE_BD" comment="Represents a mouse"/> + + <type name="XrSystemDynamicObjectMousePropertiesBD"/> + + </require> + </extension> + + <extension name="XR_BD_extension_750" number="750" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_750_SPEC_VERSION"/> + <enum value=""XR_BD_extension_750"" name="XR_BD_EXTENSION_750_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_751" number="751" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_751_SPEC_VERSION"/> + <enum value=""XR_BD_extension_751"" name="XR_BD_EXTENSION_751_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_752" number="752" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_752_SPEC_VERSION"/> + <enum value=""XR_BD_extension_752"" name="XR_BD_EXTENSION_752_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_753" number="753" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_753_SPEC_VERSION"/> + <enum value=""XR_BD_extension_753"" name="XR_BD_EXTENSION_753_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_754" number="754" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_754_SPEC_VERSION"/> + <enum value=""XR_BD_extension_754"" name="XR_BD_EXTENSION_754_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_755" number="755" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_755_SPEC_VERSION"/> + <enum value=""XR_BD_extension_755"" name="XR_BD_EXTENSION_755_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_camera_image" number="756" depends="XR_EXT_future" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_camera_image_SPEC_VERSION"/> + <enum value=""XR_BD_camera_image"" name="XR_BD_CAMERA_IMAGE_EXTENSION_NAME"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_CAMERA_UNAVAILABLE_BD" comment="The camera is not available."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_CAMERA_OCCUPIED_BD" comment="The camera is occupied by other process."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_CAMERA_CAPTURE_SESSION_CAPTURING_BD" comment="The camera capture session is capturing."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_CAMERA_CAPTURE_SESSION_NOT_CAPTURING_BD" comment="The camera capture session is not capturing."/> + <enum offset="4" dir="-" extends="XrResult" name="XR_ERROR_CAMERA_ID_INVALID_BD" comment="The camera ID is not valid."/> + <enum offset="5" dir="-" extends="XrResult" name="XR_ERROR_CAMERA_IMAGE_ID_INVALID_BD" comment="The camera image ID is not valid."/> + <enum offset="6" dir="-" extends="XrResult" name="XR_ERROR_CAMERA_PROPERTY_TYPE_INVALID_BD" comment="The camera property type is not valid."/> + <enum offset="7" dir="-" extends="XrResult" name="XR_ERROR_CAMERA_CAPABILITY_TYPE_INVALID_BD" comment="The camera capability type is not valid."/> + <enum offset="8" dir="-" extends="XrResult" name="XR_ERROR_IMAGE_BUFFER_EXHAUSTED_BD" comment="The image buffer is exhausted."/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_AVAILABLE_CAMERAS_ENUMERATE_INFO_BD"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_CAMERA_PROPERTIES_GET_INFO_BD"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_CAMERA_PROPERTIES_BD"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_CAMERA_PROPERTY_FACING_BD"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_CAMERA_PROPERTY_POSITION_BD"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_CAMERA_PROPERTY_CAMERA_TYPE_BD"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_CAMERA_SUPPORTED_CAPABILITIES_GET_INFO_BD"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_CAMERA_SUPPORTED_CAPABILITIES_BD"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_IMAGE_RESOLUTION_AND_FRAME_RATE_BD"/> + <enum offset="9" extends="XrStructureType" name="XR_TYPE_CAMERA_CAPABILITY_IMAGE_RESOLUTION_AND_FRAME_RATE_BD"/> + <enum offset="10" extends="XrStructureType" name="XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_DATA_TRANSFER_TYPE_BD"/> + <enum offset="11" extends="XrStructureType" name="XR_TYPE_CAMERA_CAPABILITY_DATA_TRANSFER_TYPE_BD"/> + <enum offset="12" extends="XrStructureType" name="XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_IMAGE_FORMAT_BD"/> + <enum offset="13" extends="XrStructureType" name="XR_TYPE_CAMERA_CAPABILITY_IMAGE_FORMAT_BD"/> + <enum offset="14" extends="XrStructureType" name="XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_CAMERA_MODEL_BD"/> + <enum offset="15" extends="XrStructureType" name="XR_TYPE_CAMERA_CAPABILITY_CAMERA_MODEL_BD"/> + <enum offset="16" extends="XrStructureType" name="XR_TYPE_CAMERA_DEVICE_CREATE_INFO_BD"/> + <enum offset="17" extends="XrStructureType" name="XR_TYPE_CREATE_CAMERA_DEVICE_COMPLETION_BD"/> + <enum offset="18" extends="XrStructureType" name="XR_TYPE_CAMERA_CAPTURE_SESSION_CREATE_INFO_BD"/> + <enum offset="19" extends="XrStructureType" name="XR_TYPE_CREATE_CAMERA_CAPTURE_SESSION_COMPLETION_BD"/> + <enum offset="20" extends="XrStructureType" name="XR_TYPE_CAMERA_INTRINSICS_BD"/> + <enum offset="21" extends="XrStructureType" name="XR_TYPE_CAMERA_EXTRINSICS_BD"/> + <enum offset="22" extends="XrStructureType" name="XR_TYPE_CAMERA_CAPTURE_BEGIN_INFO_BD"/> + <enum offset="23" extends="XrStructureType" name="XR_TYPE_CAMERA_IMAGE_ACQUIRE_INFO_BD"/> + <enum offset="24" extends="XrStructureType" name="XR_TYPE_CAMERA_IMAGE_BD"/> + <enum offset="25" extends="XrStructureType" name="XR_TYPE_CAMERA_IMAGE_DATA_RAW_BUFFER_BD"/> + <enum offset="26" extends="XrStructureType" name="XR_TYPE_CAMERA_CAPABILITIES_BD"/> + <enum offset="27" extends="XrStructureType" name="XR_TYPE_CAMERA_CAPABILITY_TYPES_ENUMERATE_INFO_BD"/> + <enum offset="28" extends="XrStructureType" name="XR_TYPE_CAMERA_CAPABILITY_TYPES_BD"/> + <enum offset="29" extends="XrStructureType" name="XR_TYPE_CAMERA_PROPERTY_TYPES_ENUMERATE_INFO_BD"/> + <enum offset="30" extends="XrStructureType" name="XR_TYPE_CAMERA_PROPERTY_TYPES_BD"/> + <enum offset="31" extends="XrStructureType" name="XR_TYPE_AVAILABLE_CAMERA_BD"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_CAMERA_DEVICE_BD" comment="XrCameraDeviceBD"/> + <enum offset="1" extends="XrObjectType" name="XR_OBJECT_TYPE_CAMERA_CAPTURE_SESSION_BD" comment="XrCameraCaptureSessionBD"/> + + <type name="XrCameraIdBD"/> + <type name="XrCameraDeviceBD"/> + <type name="XrCameraCaptureSessionBD"/> + <type name="XrAvailableCamerasEnumerateInfoBD"/> + <type name="XrAvailableCameraBD"/> + <type name="XrCameraPropertyTypeBD"/> + <type name="XrCameraPropertyTypesEnumerateInfoBD"/> + <type name="XrCameraPropertyTypesBD"/> + <type name="XrCameraPropertiesGetInfoBD"/> + <type name="XrCameraPropertiesBD"/> + <type name="XrCameraPropertyBaseHeaderBD"/> + <type name="XrCameraFacingBD"/> + <type name="XrCameraPropertyFacingBD"/> + <type name="XrCameraPositionBD"/> + <type name="XrCameraPropertyPositionBD"/> + <type name="XrCameraTypeBD"/> + <type name="XrCameraPropertyCameraTypeBD"/> + <type name="XrCameraCapabilityTypeBD"/> + <type name="XrCameraCapabilityTypesEnumerateInfoBD"/> + <type name="XrCameraCapabilityTypesBD"/> + <type name="XrCameraSupportedCapabilitiesGetInfoBD"/> + <type name="XrCameraSupportedCapabilityBaseHeaderBD"/> + <type name="XrCameraSupportedCapabilitiesBD"/> + <type name="XrCameraCapabilityBaseHeaderBD"/> + <type name="XrCameraCapabilitiesBD"/> + <type name="XrCameraImageResolutionAndFrameRateBD"/> + <type name="XrCameraSupportedCapabilityImageResolutionAndFrameRateBD"/> + <type name="XrCameraCapabilityImageResolutionAndFrameRateBD"/> + <type name="XrCameraDataTransferTypeBD"/> + <type name="XrCameraSupportedCapabilityDataTransferTypeBD"/> + <type name="XrCameraCapabilityDataTransferTypeBD"/> + <type name="XrCameraImageFormatBD"/> + <type name="XrCameraSupportedCapabilityImageFormatBD"/> + <type name="XrCameraCapabilityImageFormatBD"/> + <type name="XrCameraModelBD"/> + <type name="XrCameraSupportedCapabilityCameraModelBD"/> + <type name="XrCameraCapabilityCameraModelBD"/> + <type name="XrCameraDeviceCreateInfoBD"/> + <type name="XrCreateCameraDeviceCompletionBD"/> + <type name="XrCameraCaptureSessionCreateInfoBD"/> + <type name="XrCreateCameraCaptureSessionCompletionBD"/> + <type name="XrCameraIntrinsicsBD"/> + <type name="XrCameraExtrinsicsBD"/> + <type name="XrCameraCaptureBeginInfoBD"/> + <type name="XrCameraImageAcquireInfoBD"/> + <type name="XrCameraImageIdBD"/> + <type name="XrCameraImageBD"/> + <type name="XrCameraImageDataBaseHeaderBD"/> + <type name="XrCameraImageDataRawBufferBD"/> + + <command name="xrEnumerateAvailableCamerasBD"/> + <command name="xrEnumerateCameraPropertyTypesBD"/> + + <command name="xrGetCameraPropertiesBD"/> + <command name="xrEnumerateCameraCapabilityTypesBD"/> + <command name="xrGetCameraSupportedCapabilitiesBD"/> + <command name="xrCreateCameraDeviceAsyncBD"/> + <command name="xrCreateCameraDeviceCompleteBD"/> + <command name="xrDestroyCameraDeviceBD"/> + <command name="xrCreateCameraCaptureSessionAsyncBD"/> + <command name="xrCreateCameraCaptureSessionCompleteBD"/> + <command name="xrDestroyCameraCaptureSessionBD"/> + <command name="xrBeginCameraCaptureBD"/> + <command name="xrEndCameraCaptureBD"/> + <command name="xrAcquireCameraImageBD"/> + <command name="xrGetCameraImageDataBD"/> + <command name="xrReleaseCameraImageBD"/> + </require> + </extension> + + <extension name="XR_BD_extension_757" number="757" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_757_SPEC_VERSION"/> + <enum value=""XR_BD_extension_757"" name="XR_BD_EXTENSION_757_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_758" number="758" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_758_SPEC_VERSION"/> + <enum value=""XR_BD_extension_758"" name="XR_BD_EXTENSION_758_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_759" number="759" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_759_SPEC_VERSION"/> + <enum value=""XR_BD_extension_759"" name="XR_BD_EXTENSION_759_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_760" number="760" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_760_SPEC_VERSION"/> + <enum value=""XR_BD_extension_760"" name="XR_BD_EXTENSION_760_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_761" number="761" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_761_SPEC_VERSION"/> + <enum value=""XR_BD_extension_761"" name="XR_BD_EXTENSION_761_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_spatial_discovery_bounds" number="762" type="instance" supported="openxr" depends="XR_EXT_spatial_entity"> + <require> + <enum value="1" name="XR_ANDROID_spatial_discovery_bounds_SPEC_VERSION"/> + <enum value=""XR_ANDROID_spatial_discovery_bounds"" name="XR_ANDROID_SPATIAL_DISCOVERY_BOUNDS_EXTENSION_NAME"/> + + <enum offset="0" extends="XrSpatialCapabilityFeatureEXT" name="XR_SPATIAL_CAPABILITY_FEATURE_SPHERE_BOUNDS_FILTER_ANDROID" comment="The runtime supports slink:XrSpatialBoundsSpherefANDROID filter for slink:XrSpatialDiscoverySnapshotCreateInfoEXT; This does not require any configuration structure to be included during spatial context creation."/> + <enum offset="1" extends="XrSpatialCapabilityFeatureEXT" name="XR_SPATIAL_CAPABILITY_FEATURE_BOX_BOUNDS_FILTER_ANDROID" comment="The runtime supports slink:XrSpatialBoundsBoxfANDROID filter for slink:XrSpatialDiscoverySnapshotCreateInfoEXT; This does not require any configuration structure to be included during spatial context creation."/> + <enum offset="2" extends="XrSpatialCapabilityFeatureEXT" name="XR_SPATIAL_CAPABILITY_FEATURE_FRUSTUM_BOUNDS_FILTER_ANDROID" comment="The runtime supports slink:XrSpatialBoundsFrustumfANDROID filter for slink:XrSpatialDiscoverySnapshotCreateInfoEXT; This does not require any configuration structure to be included during spatial context creation."/> + + <type name="XrSpatialBoundsSpherefANDROID"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_BOUNDS_SPHEREF_ANDROID"/> + <type name="XrSpatialBoundsBoxfANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_BOUNDS_BOXF_ANDROID"/> + <type name="XrSpatialBoundsFrustumfANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_BOUNDS_FRUSTUMF_ANDROID"/> + </require> + </extension> + + <extension name="XR_EXT_spatial_anchor" number="763" type="instance" supported="openxr" depends="XR_EXT_spatial_entity" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_spatial_anchor_SPEC_VERSION"/> + <enum value=""XR_EXT_spatial_anchor"" name="XR_EXT_SPATIAL_ANCHOR_EXTENSION_NAME"/> + + <enum offset="0" extends="XrSpatialCapabilityEXT" name="XR_SPATIAL_CAPABILITY_ANCHOR_EXT" comment="Capability to be able to create spatial anchors"/> + + <enum offset="0" extends="XrSpatialComponentTypeEXT" name="XR_SPATIAL_COMPONENT_TYPE_ANCHOR_EXT" comment="Component that provides the location for an anchor. Corresponding list structure is slink:XrSpatialComponentAnchorListEXT; Corresponding data structure is slink:XrPosef"/> + + <type name="XrSpatialCapabilityConfigurationAnchorEXT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ANCHOR_EXT"/> + <type name="XrSpatialComponentAnchorListEXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_ANCHOR_LIST_EXT"/> + <type name="XrSpatialAnchorCreateInfoEXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_EXT"/> + + <command name="xrCreateSpatialAnchorEXT"/> + </require> + </extension> + + <extension name="XR_EXT_spatial_persistence" number="764" type="instance" supported="openxr" depends="XR_EXT_spatial_entity+XR_EXT_future" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_spatial_persistence_SPEC_VERSION"/> + <enum value=""XR_EXT_spatial_persistence"" name="XR_EXT_SPATIAL_PERSISTENCE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrSpatialComponentTypeEXT" name="XR_SPATIAL_COMPONENT_TYPE_PERSISTENCE_EXT" comment="Component that provides the persisted UUID for a spatial entity. Corresponding list structure is slink:XrSpatialComponentPersistenceListEXT; Corresponding data structure is slink:XrSpatialPersistenceDataEXT"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SPATIAL_PERSISTENCE_CONTEXT_EXT" comment="XrSpatialPersistenceContextEXT"/> + + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_PERSISTENCE_SCOPE_UNSUPPORTED_EXT" comment="The specified spatial persistence scope is not supported by the runtime or the system."/> + + <type name="XrSpatialPersistenceContextEXT"/> + + <type name="XrSpatialPersistenceScopeEXT"/> + <type name="XrSpatialPersistenceContextResultEXT"/> + <type name="XrSpatialPersistenceStateEXT"/> + + <type name="XrSpatialPersistenceContextCreateInfoEXT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_PERSISTENCE_CONTEXT_CREATE_INFO_EXT"/> + <type name="XrCreateSpatialPersistenceContextCompletionEXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_CREATE_SPATIAL_PERSISTENCE_CONTEXT_COMPLETION_EXT"/> + <type name="XrSpatialContextPersistenceConfigEXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_CONTEXT_PERSISTENCE_CONFIG_EXT"/> + <type name="XrSpatialDiscoveryPersistenceUuidFilterEXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPATIAL_DISCOVERY_PERSISTENCE_UUID_FILTER_EXT"/> + <type name="XrSpatialPersistenceDataEXT"/> + <type name="XrSpatialComponentPersistenceListEXT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_PERSISTENCE_LIST_EXT"/> + + <command name="xrEnumerateSpatialPersistenceScopesEXT"/> + <command name="xrCreateSpatialPersistenceContextAsyncEXT"/> + <command name="xrCreateSpatialPersistenceContextCompleteEXT"/> + <command name="xrDestroySpatialPersistenceContextEXT"/> + </require> + </extension> + + <extension name="XR_EPIC_extension_765" number="765" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EPIC_extension_765_SPEC_VERSION"/> + <enum value=""XR_EPIC_extension_765"" name="XR_EPIC_extension_765_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EPIC_extension_766" number="766" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EPIC_extension_766_SPEC_VERSION"/> + <enum value=""XR_EPIC_extension_766"" name="XR_EPIC_extension_766_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EPIC_extension_767" number="767" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EPIC_extension_767_SPEC_VERSION"/> + <enum value=""XR_EPIC_extension_767"" name="XR_EPIC_extension_767_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EPIC_extension_768" number="768" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EPIC_extension_768_SPEC_VERSION"/> + <enum value=""XR_EPIC_extension_768"" name="XR_EPIC_extension_768_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EPIC_extension_769" number="769" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EPIC_extension_769_SPEC_VERSION"/> + <enum value=""XR_EPIC_extension_769"" name="XR_EPIC_extension_769_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EPIC_extension_770" number="770" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EPIC_extension_770_SPEC_VERSION"/> + <enum value=""XR_EPIC_extension_770"" name="XR_EPIC_extension_770_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EPIC_extension_771" number="771" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EPIC_extension_771_SPEC_VERSION"/> + <enum value=""XR_EPIC_extension_771"" name="XR_EPIC_extension_771_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EPIC_extension_772" number="772" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EPIC_extension_772_SPEC_VERSION"/> + <enum value=""XR_EPIC_extension_772"" name="XR_EPIC_extension_772_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EPIC_extension_773" number="773" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EPIC_extension_773_SPEC_VERSION"/> + <enum value=""XR_EPIC_extension_773"" name="XR_EPIC_extension_773_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EPIC_extension_774" number="774" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EPIC_extension_774_SPEC_VERSION"/> + <enum value=""XR_EPIC_extension_774"" name="XR_EPIC_extension_774_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_KHR_hand_tracking" number="775" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_KHR_hand_tracking_SPEC_VERSION"/> + <enum value=""XR_KHR_hand_tracking"" name="XR_KHR_HAND_TRACKING_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_haptic_parametric" number="776" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_EXT_haptic_parametric_SPEC_VERSION"/> + <enum value=""XR_EXT_haptic_parametric"" name="XR_EXT_HAPTIC_PARAMETRIC_EXTENSION_NAME"/> + + <type name="XR_HAPTIC_PARAMETRIC_MAX_POINTS_TRANSIENTS_EXT"/> + <type name="XR_HAPTIC_PARAMETRIC_VIBRATION_EXTEND_DURATION_EXT"/> + <type name="XR_HAPTIC_PARAMETRIC_FREQUENCY_MIN_HZ_EXT"/> + <type name="XR_HAPTIC_PARAMETRIC_FREQUENCY_MAX_HZ_EXT"/> + <type name="XrHapticParametricPropertiesEXT"/> + <type name="XrHapticParametricPointEXT"/> + <type name="XrHapticParametricTransientEXT"/> + <type name="XrHapticParametricVibrationEXT"/> + <type name="XrHapticParametricStreamFrameTypeEXT"/> + <type name="XrSystemHapticParametricPropertiesEXT"/> + + <command name="xrHapticParametricGetPropertiesEXT"/> + + <extend type="command" name="xrApplyHapticFeedback" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_HAPTIC_PARAMETRIC_VIBRATION_EXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_HAPTIC_PARAMETRIC_PROPERTIES_EXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SYSTEM_HAPTIC_PARAMETRIC_PROPERTIES_EXT"/> + </require> + </extension> + + <extension name="XR_SONY_swapchain_color_space" number="777" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_SONY_swapchain_color_space_SPEC_VERSION"/> + <enum value=""XR_SONY_swapchain_color_space"" name="XR_SONY_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COLOR_SPACES_ENUMERATE_INFO_SONY"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_CREATE_INFO_COLOR_SPACE_SONY"/> + + <type name="XrColorSpaceSONY"/> + <type name="XrColorSpacesEnumerateInfoSONY"/> + <type name="XrSwapchainCreateInfoColorSpaceSONY"/> + + <command name="xrEnumerateColorSpacesSONY"/> + </require> + </extension> + + <extension name="XR_SONY_hdr_metadata" number="778" type="instance" supported="openxr" depends="XR_SONY_swapchain_color_space"> + <require> + <enum value="1" name="XR_SONY_hdr_metadata_SPEC_VERSION"/> + <enum value=""XR_SONY_hdr_metadata"" name="XR_SONY_HDR_METADATA_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_HDR_METADATA_SONY"/> + + <type name="XrHdrMetadataSONY"/> + <type name="XrXYColorSONY"/> + + <command name="xrSetHdrMetadataSONY"/> + </require> + </extension> + + <extension name="XR_SONY_extension_779" number="779" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_SONY_extension_779_SPEC_VERSION"/> + <enum value=""XR_SONY_extension_779"" name="XR_SONY_EXTENSION_779_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_SONY_extension_780" number="780" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_SONY_extension_780_SPEC_VERSION"/> + <enum value=""XR_SONY_extension_780"" name="XR_SONY_EXTENSION_780_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_SONY_extension_781" number="781" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_SONY_extension_781_SPEC_VERSION"/> + <enum value=""XR_SONY_extension_781"" name="XR_SONY_EXTENSION_781_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_spatial_persistence_operations" number="782" type="instance" supported="openxr" depends="XR_EXT_spatial_persistence+XR_EXT_future" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_spatial_persistence_operations_SPEC_VERSION"/> + <enum value=""XR_EXT_spatial_persistence_operations"" name="XR_EXT_SPATIAL_PERSISTENCE_OPERATIONS_EXTENSION_NAME"/> + + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_PERSISTENCE_SCOPE_INCOMPATIBLE_EXT" comment="The scope configured for the persistence context is incompatible for the current spatial entity."/> + + <enum offset="0" extends="XrSpatialPersistenceScopeEXT" name="XR_SPATIAL_PERSISTENCE_SCOPE_LOCAL_ANCHORS_EXT" comment="Persistence operations and data access is limited to spatial anchors, on the same device, for the same user and same app"/> + + <enum offset="1" dir="-" extends="XrSpatialPersistenceContextResultEXT" name="XR_SPATIAL_PERSISTENCE_CONTEXT_RESULT_ENTITY_NOT_TRACKING_EXT" comment="The persistence operation failed because the entity could not be tracked by the runtime."/> + <enum offset="2" dir="-" extends="XrSpatialPersistenceContextResultEXT" name="XR_SPATIAL_PERSISTENCE_CONTEXT_RESULT_PERSIST_UUID_NOT_FOUND_EXT" comment="The provided persist UUID was not found in the storage."/> + + <type name="XrSpatialEntityPersistInfoEXT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_PERSIST_INFO_EXT"/> + <type name="XrPersistSpatialEntityCompletionEXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_PERSIST_SPATIAL_ENTITY_COMPLETION_EXT"/> + <type name="XrSpatialEntityUnpersistInfoEXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_UNPERSIST_INFO_EXT"/> + <type name="XrUnpersistSpatialEntityCompletionEXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_UNPERSIST_SPATIAL_ENTITY_COMPLETION_EXT"/> + + <command name="xrPersistSpatialEntityAsyncEXT"/> + <command name="xrPersistSpatialEntityCompleteEXT"/> + <command name="xrUnpersistSpatialEntityAsyncEXT"/> + <command name="xrUnpersistSpatialEntityCompleteEXT"/> + </require> + </extension> + + <extension name="XR_EXT_spatial_image_tracking" number="783" type="instance" fragment="true"/> + + <extension name="XR_EXT_extension_784" number="784" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_784_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_784"" name="XR_EXT_EXTENSION_784_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_785" number="785" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_785_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_785"" name="XR_EXT_EXTENSION_785_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_spatial_object_tracking" number="786" type="instance" supported="openxr" depends="XR_EXT_spatial_entity"> + <require> + <enum value="2" name="XR_ANDROID_spatial_object_tracking_SPEC_VERSION"/> + <enum value=""XR_ANDROID_spatial_object_tracking"" name="XR_ANDROID_SPATIAL_OBJECT_TRACKING_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_OBJECT_TRACKING_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_OBJECT_SEMANTIC_LABEL_LIST_ANDROID"/> + + <enum offset="0" extends="XrSpatialCapabilityEXT" name="XR_SPATIAL_CAPABILITY_OBJECT_TRACKING_ANDROID" comment="Object tracking"/> + <enum offset="0" extends="XrSpatialComponentTypeEXT" name="XR_SPATIAL_COMPONENT_TYPE_OBJECT_SEMANTIC_LABEL_ANDROID" comment="Component that provides a semantic label for a object; Corresponding list structure is slink:XrSpatialComponentObjectSemanticLabelListANDROID; Corresponding data structure is elink:XrSpatialObjectSemanticLabelANDROID"/> + <type name="XrSpatialObjectSemanticLabelANDROID"/> + <type name="XrSpatialCapabilityConfigurationObjectTrackingANDROID"/> + <type name="XrSpatialComponentObjectSemanticLabelListANDROID"/> + </require> + </extension> + + <!-- XR_ANDROID_spatial_discovery_raycast --> + <extension name="XR_ANDROID_spatial_discovery_raycast" number="787" type="instance" supported="openxr" depends="XR_EXT_spatial_entity"> + <require> + <enum value="1" name="XR_ANDROID_spatial_discovery_raycast_SPEC_VERSION"/> + <enum value=""XR_ANDROID_spatial_discovery_raycast"" name="XR_ANDROID_SPATIAL_DISCOVERY_RAYCAST_EXTENSION_NAME"/> + + <enum offset="0" extends="XrSpatialCapabilityEXT" name="XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID" comment="Raycast against depth buffer"/> + <enum offset="0" extends="XrSpatialComponentTypeEXT" name="XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID" comment="Component that provides the pose of a raycast hit on an entity. Corresponding list structure is slink:XrSpatialComponentRaycastResultListANDROID; Corresponding data structure is slink:XrSpatialRaycastResultDataANDROID"/> + + <type name="XrSpatialRaycastResultDataANDROID"/> + + <type name="XrSpatialCapabilityConfigurationDepthRaycastANDROID"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_DEPTH_RAYCAST_ANDROID"/> + <type name="XrSpatialRaycastInfoANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_RAYCAST_INFO_ANDROID"/> + <type name="XrSpatialComponentRaycastResultListANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_RAYCAST_RESULT_LIST_ANDROID"/> + <type name="XrSpatialRaycastSnapshotCreateInfoANDROID"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPATIAL_RAYCAST_SNAPSHOT_CREATE_INFO_ANDROID"/> + + <command name="xrCreateSpatialRaycastSnapshotANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_google_cloud_auth" number="788" type="instance" supported="openxr" depends="XR_EXT_future"> + <require> + <enum value="1" name="XR_ANDROID_google_cloud_auth_SPEC_VERSION"/> + <enum value=""XR_ANDROID_google_cloud_auth"" name="XR_ANDROID_GOOGLE_CLOUD_AUTH_EXTENSION_NAME"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_KEYLESS_AUTH_NOT_SETUP_ANDROID" comment="Keyless auth is not setup properly."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_KEYLESS_AUTH_FAILED_ANDROID" comment="Keyless auth failed. The application can: try again later. The application or developer may: also check certain preconditions for success (e.g. on Android, the device must: have an up-to-date installation of Google Play Services and these services must: be functioning properly)."/> + + <type name="XrGoogleCloudAuthInfoBaseHeaderANDROID"/> + <type name="XrGoogleCloudAuthInfoApiKeyANDROID"/> + <type name="XrGoogleCloudAuthInfoTokenANDROID"/> + <type name="XrGoogleCloudAuthInfoKeylessANDROID"/> + <type name="XrGoogleCloudAuthErrorANDROID"/> + <type name="XrGoogleCloudAuthErrorResultANDROID"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_API_KEY_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_TOKEN_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_KEYLESS_ANDROID"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_GOOGLE_CLOUD_AUTH_ERROR_RESULT_ANDROID"/> + + <command name="xrSetGoogleCloudAuthAsyncANDROID"/> + <command name="xrSetGoogleCloudAuthCompleteANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_789" number="789" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_789_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_789"" name="XR_ANDROID_EXTENSION_789_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_geospatial" number="790" type="instance" supported="openxr" depends="XR_EXT_future"> + <require> + <enum value="1" name="XR_ANDROID_geospatial_SPEC_VERSION"/> + <enum value=""XR_ANDROID_geospatial"" name="XR_ANDROID_GEOSPATIAL_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_GEOSPATIAL_PROPERTIES_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_GEOSPATIAL_TRACKER_CREATE_INFO_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_GEOSPATIAL_TRACKER_STATE_CHANGED_ANDROID"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_GEOSPATIAL_POSE_FROM_POSE_LOCATE_INFO_ANDROID"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_GEOSPATIAL_POSE_RESULT_ANDROID"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_GEOSPATIAL_POSE_LOCATE_INFO_ANDROID"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_VPS_AVAILABILITY_CHECK_COMPLETION_ANDROID"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_GEOSPATIAL_TRACKER_ANDROID" comment="XrGeospatialTrackerANDROID"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_GEOSPATIAL_TRACKER_NOT_RUNNING_ANDROID" comment="An slink:XrGeospatialTrackerANDROID which is not in ename:XR_GEOSPATIAL_TRACKER_STATE_RUNNING_ANDROID was passed to a function."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_GEOSPATIAL_COORDINATES_INVALID_ANDROID" comment="The supplied geospatial coordinates were invalid."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_GEOSPATIAL_CLOUD_AUTH_FAILED_ANDROID" comment="Cloud auth failed. A structure like slink:XrGoogleCloudAuthErrorResultANDROID in the next chain may: provide more information about the failure."/> + + <type name="XrGeospatialPoseANDROID"/> + <type name="XrSystemGeospatialPropertiesANDROID"/> + <type name="XrGeospatialTrackerANDROID"/> + <type name="XrGeospatialTrackerStateANDROID"/> + <type name="XrGeospatialTrackerCreateInfoANDROID"/> + <type name="XrEventDataGeospatialTrackerStateChangedANDROID"/> + <type name="XrGeospatialPoseFlagsANDROID"/> + <type name="XrGeospatialPoseFlagBitsANDROID"/> + <type name="XrGeospatialPoseFromPoseLocateInfoANDROID"/> + <type name="XrGeospatialPoseResultANDROID"/> + <type name="XrGeospatialPoseLocateInfoANDROID"/> + <type name="XrVPSAvailabilityANDROID"/> + <type name="XrVPSAvailabilityCheckCompletionANDROID"/> + + <command name="xrCreateGeospatialTrackerANDROID"/> + <command name="xrDestroyGeospatialTrackerANDROID"/> + <command name="xrLocateGeospatialPoseFromPoseANDROID"/> + <command name="xrLocateGeospatialPoseANDROID"/> + <command name="xrCheckVpsAvailabilityAsyncANDROID"/> + <command name="xrCheckVpsAvailabilityCompleteANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_spatial_entity_bound_anchor" number="791" type="instance" supported="openxr" depends="XR_EXT_spatial_anchor"> + <require> + <enum value="2" name="XR_ANDROID_spatial_entity_bound_anchor_SPEC_VERSION"/> + <enum value=""XR_ANDROID_spatial_entity_bound_anchor"" name="XR_ANDROID_SPATIAL_ENTITY_BOUND_ANCHOR_EXTENSION_NAME"/> + + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHOR_ATTACHABLE_COMPONENT_NOT_FOUND_ANDROID" comment="Spatial entity with parent ID does not have at least one component enumerated by xrEnumerateSpatialAnchorAttachableComponentsANDROID"/> + + <type name="XrSpatialAnchorParentANDROID"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_PARENT_ANDROID"/> + + <extend type="command" name="xrCreateSpatialAnchorEXT" errorcodes="XR_ERROR_SPATIAL_ANCHOR_ATTACHABLE_COMPONENT_NOT_FOUND_ANDROID,XR_ERROR_SPATIAL_ENTITY_ID_INVALID_EXT"/> + + <command name="xrEnumerateSpatialAnchorAttachableComponentsANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_spatial_component_subsumed_by" number="792" type="instance" supported="openxr" depends="XR_EXT_spatial_entity+XR_EXT_spatial_plane_tracking"> + <require> + <enum value="1" name="XR_ANDROID_spatial_component_subsumed_by_SPEC_VERSION"/> + <enum value=""XR_ANDROID_spatial_component_subsumed_by"" name="XR_ANDROID_SPATIAL_COMPONENT_SUBSUMED_BY_EXTENSION_NAME"/> + + <enum offset="0" extends="XrSpatialComponentTypeEXT" name="XR_SPATIAL_COMPONENT_TYPE_SUBSUMED_BY_ANDROID" comment="Component that provides entity ID of the entity subsuming the attached entity. Corresponding list structure is slink:XrSpatialComponentSubsumedByListANDROID; Corresponding data structure is basetype:XrSpatialEntityIdEXT"/> + <type name="XrSpatialDiscoveryUniqueEntitiesFilterANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_DISCOVERY_UNIQUE_ENTITIES_FILTER_ANDROID"/> + <type name="XrSpatialComponentSubsumedByListANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_SUBSUMED_BY_LIST_ANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_793" number="793" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_793_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_793"" name="XR_ANDROID_EXTENSION_793_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_794" number="794" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_794_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_794"" name="XR_ANDROID_EXTENSION_794_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_795" number="795" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_795_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_795"" name="XR_ANDROID_EXTENSION_795_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_spatial_anchor_space" number="796" type="instance" supported="openxr" depends="XR_EXT_spatial_anchor"> + <require> + <enum value="1" name="XR_ANDROID_spatial_anchor_space_SPEC_VERSION"/> + <enum value=""XR_ANDROID_spatial_anchor_space"" name="XR_ANDROID_SPATIAL_ANCHOR_SPACE_EXTENSION_NAME"/> + + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHOR_ENTITY_ID_INVALID_ANDROID" comment="The specified spatial entity ID is invalid for an anchor."/> + + <type name="XrSpatialAnchorSpaceFromIdCreateInfoANDROID"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_SPACE_FROM_ID_CREATE_INFO_ANDROID"/> + + <command name="xrCreateSpatialAnchorSpaceANDROID"/> + <command name="xrCreateSpatialAnchorSpaceFromIdANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_797" number="797" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_797_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_797"" name="XR_ANDROID_EXTENSION_797_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_geospatial_anchor" number="798" type="instance" supported="openxr" depends="XR_ANDROID_geospatial+XR_EXT_future+XR_EXT_spatial_entity+XR_EXT_spatial_anchor"> + <require> + <enum value="1" name="XR_ANDROID_geospatial_anchor_SPEC_VERSION"/> + <enum value=""XR_ANDROID_geospatial_anchor"" name="XR_ANDROID_GEOSPATIAL_ANCHOR_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_GEOSPATIAL_ANCHOR_CREATE_INFO_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SURFACE_ANCHOR_CREATE_INFO_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SURFACE_ANCHOR_CREATE_COMPLETION_ANDROID"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SYSTEM_GEOSPATIAL_ANCHOR_PROPERTIES_ANDROID"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_GEOSPATIAL_TRACKER_ANCHOR_TRACKING_INFO_ANDROID"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SURFACE_ANCHOR_LOCATION_UNSUPPORTED_ANDROID" comment="There is no surface data for the given location."/> + + <type name="XrSystemGeospatialAnchorPropertiesANDROID"/> + <type name="XrGeospatialTrackerAnchorTrackingInfoANDROID"/> + <type name="XrGeospatialAnchorCreateInfoANDROID"/> + <type name="XrSurfaceAnchorTypeANDROID"/> + <type name="XrSurfaceAnchorCreateInfoANDROID"/> + <type name="XrSurfaceAnchorCreateCompletionANDROID"/> + + <command name="xrCreateGeospatialAnchorANDROID"/> + <command name="xrCreateSurfaceAnchorAsyncANDROID"/> + <command name="xrCreateSurfaceAnchorCompleteANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_799" number="799" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_799_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_799"" name="XR_ANDROID_EXTENSION_799_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_800" number="800" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_800_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_800"" name="XR_ANDROID_EXTENSION_800_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_801" number="801" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_801_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_801"" name="XR_ANDROID_EXTENSION_801_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_802" number="802" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_802_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_802"" name="XR_ANDROID_EXTENSION_802_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_803" number="803" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_803_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_803"" name="XR_ANDROID_EXTENSION_803_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_804" number="804" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_804_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_804"" name="XR_ANDROID_EXTENSION_804_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_805" number="805" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_805_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_805"" name="XR_ANDROID_EXTENSION_805_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_806" number="806" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_806_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_806"" name="XR_ANDROID_EXTENSION_806_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_807" number="807" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_807_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_807"" name="XR_ANDROID_EXTENSION_807_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_808" number="808" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_808_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_808"" name="XR_ANDROID_EXTENSION_808_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_809" number="809" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_809_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_809"" name="XR_ANDROID_EXTENSION_809_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_810" number="810" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_810_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_810"" name="XR_ANDROID_EXTENSION_810_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_spatial_container" number="811" type="instance" fragment="true"/> + + <extension name="XR_ANDROID_extension_812" number="812" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_812_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_812"" name="XR_ANDROID_EXTENSION_812_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_813" number="813" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_813_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_813"" name="XR_ANDROID_EXTENSION_813_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_spatial_container_self_rendering" number="814" type="instance" fragment="true"/> + + <extension name="XR_ANDROID_extension_815" number="815" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_815_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_815"" name="XR_ANDROID_EXTENSION_815_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_816" number="816" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_816_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_816"" name="XR_ANDROID_EXTENSION_816_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_817" number="817" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_817_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_817"" name="XR_ANDROID_EXTENSION_817_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_818" number="818" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_818_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_818"" name="XR_ANDROID_EXTENSION_818_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_819" number="819" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_819_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_819"" name="XR_ANDROID_EXTENSION_819_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_820" number="820" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_820_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_820"" name="XR_ANDROID_EXTENSION_820_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_821" number="821" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_821_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_821"" name="XR_ANDROID_EXTENSION_821_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_822" number="822" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_822_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_822"" name="XR_ANDROID_EXTENSION_822_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_823" number="823" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_823_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_823"" name="XR_ANDROID_EXTENSION_823_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_824" number="824" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_824_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_824"" name="XR_ANDROID_EXTENSION_824_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_825" number="825" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_825_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_825"" name="XR_ANDROID_EXTENSION_825_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_826" number="826" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_826_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_826"" name="XR_ANDROID_EXTENSION_826_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_827" number="827" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_827_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_827"" name="XR_ANDROID_EXTENSION_827_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_828" number="828" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_828_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_828"" name="XR_ANDROID_EXTENSION_828_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_829" number="829" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_829_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_829"" name="XR_ANDROID_EXTENSION_829_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_830" number="830" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_830_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_830"" name="XR_ANDROID_EXTENSION_830_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_831" number="831" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_831_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_831"" name="XR_ANDROID_EXTENSION_831_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_832" number="832" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_832_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_832"" name="XR_ANDROID_EXTENSION_832_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_833" number="833" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_833_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_833"" name="XR_ANDROID_EXTENSION_833_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_834" number="834" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_834_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_834"" name="XR_ANDROID_EXTENSION_834_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_835" number="835" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_835_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_835"" name="XR_ANDROID_EXTENSION_835_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_836" number="836" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_836_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_836"" name="XR_EXT_EXTENSION_836_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_interaction_profile_battery_state_display" number="837" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_interaction_profile_battery_state_display_SPEC_VERSION"/> + <enum value=""XR_EXT_interaction_profile_battery_state_display"" name="XR_EXT_INTERACTION_PROFILE_BATTERY_STATE_DISPLAY_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_BATTERY_STATE_DISPLAY_EXT"/> + + <type name="XrBatteryStateDisplayEXT"/> + <type name="XrBatteryStateDisplayStateFlagsEXT"/> + <type name="XrBatteryStateDisplayStateFlagBitsEXT"/> + </require> + </extension> + + <extension name="XR_KHR_extension_838" number="838" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_KHR_extension_838_SPEC_VERSION"/> + <enum value=""XR_KHR_extension_838"" name="XR_KHR_EXTENSION_838_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_loader_init_properties" number="839" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_EXT_loader_init_properties_SPEC_VERSION"/> + <enum value=""XR_EXT_loader_init_properties"" name="XR_EXT_LOADER_INIT_PROPERTIES_EXTENSION_NAME"/> + <type name="XrLoaderInitInfoPropertiesEXT"/> + <type name="XrLoaderInitPropertyValueEXT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_LOADER_INIT_INFO_PROPERTIES_EXT"/> + </require> + </extension> + + <extension name="XR_EXT_view_configuration_views_change" number="840" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_EXT_view_configuration_views_change_SPEC_VERSION"/> + <enum value=""XR_EXT_view_configuration_views_change"" name="XR_EXT_VIEW_CONFIGURATION_VIEWS_CHANGE_EXTENSION_NAME"/> + + <type name="XrEventDataViewConfigurationViewsChangedEXT"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_VIEW_CONFIGURATION_VIEWS_CHANGED_EXT"/> + </require> + </extension> + + <extension name="XR_KHR_extension_841" number="841" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_KHR_extension_841_SPEC_VERSION"/> + <enum value=""XR_KHR_extension_841"" name="XR_KHR_EXTENSION_841_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_842" number="842" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_842_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_842"" name="XR_EXT_EXTENSION_842_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_843" number="843" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_843_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_843"" name="XR_EXT_EXTENSION_843_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_844" number="844" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_844_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_844"" name="XR_EXT_EXTENSION_844_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_845" number="845" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_845_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_845"" name="XR_EXT_EXTENSION_845_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_846" number="846" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_846_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_846"" name="XR_EXT_EXTENSION_846_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_847" number="847" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_847_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_847"" name="XR_EXT_EXTENSION_847_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_848" number="848" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_848_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_848"" name="XR_EXT_EXTENSION_848_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_849" number="849" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_849_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_849"" name="XR_EXT_EXTENSION_849_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_850" number="850" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_850_SPEC_VERSION"/> + <enum value=""XR_NV_extension_850"" name="XR_NV_EXTENSION_850_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_851" number="851" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_851_SPEC_VERSION"/> + <enum value=""XR_NV_extension_851"" name="XR_NV_EXTENSION_851_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_852" number="852" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_852_SPEC_VERSION"/> + <enum value=""XR_NV_extension_852"" name="XR_NV_EXTENSION_852_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_853" number="853" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_853_SPEC_VERSION"/> + <enum value=""XR_NV_extension_853"" name="XR_NV_EXTENSION_853_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_854" number="854" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_854_SPEC_VERSION"/> + <enum value=""XR_NV_extension_854"" name="XR_NV_EXTENSION_854_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_855" number="855" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_855_SPEC_VERSION"/> + <enum value=""XR_NV_extension_855"" name="XR_NV_EXTENSION_855_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_856" number="856" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_856_SPEC_VERSION"/> + <enum value=""XR_NV_extension_856"" name="XR_NV_EXTENSION_856_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_857" number="857" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_857_SPEC_VERSION"/> + <enum value=""XR_NV_extension_857"" name="XR_NV_EXTENSION_857_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_858" number="858" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_858_SPEC_VERSION"/> + <enum value=""XR_NV_extension_858"" name="XR_NV_EXTENSION_858_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_859" number="859" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_859_SPEC_VERSION"/> + <enum value=""XR_NV_extension_859"" name="XR_NV_EXTENSION_859_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_860" number="860" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_860_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_860"" name="XR_QCOM_EXTENSION_860_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_861" number="861" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_861_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_861"" name="XR_QCOM_EXTENSION_861_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_862" number="862" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_862_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_862"" name="XR_QCOM_EXTENSION_862_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_863" number="863" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_863_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_863"" name="XR_QCOM_EXTENSION_863_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_864" number="864" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_864_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_864"" name="XR_QCOM_EXTENSION_864_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_865" number="865" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_865_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_865"" name="XR_QCOM_EXTENSION_865_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_866" number="866" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_866_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_866"" name="XR_QCOM_EXTENSION_866_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_867" number="867" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_867_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_867"" name="XR_QCOM_EXTENSION_867_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_868" number="868" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_868_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_868"" name="XR_QCOM_EXTENSION_868_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_869" number="869" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_869_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_869"" name="XR_QCOM_EXTENSION_869_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_870" number="870" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_870_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_870"" name="XR_EXT_EXTENSION_870_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_871" number="871" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_871_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_871"" name="XR_EXT_EXTENSION_871_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_KHR_extension_872" number="872" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_KHR_extension_872_SPEC_VERSION"/> + <enum value=""XR_KHR_extension_872"" name="XR_KHR_EXTENSION_872_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_KHR_extension_873" number="873" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_KHR_extension_873_SPEC_VERSION"/> + <enum value=""XR_KHR_extension_873"" name="XR_KHR_EXTENSION_873_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_874" number="874" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_874_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_874"" name="XR_EXT_EXTENSION_874_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_KHR_extended_result_name_lengths" number="875" type="instance" fragment="true"/> + + <extension name="XR_EXT_extension_876" number="876" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_876_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_876"" name="XR_EXT_EXTENSION_876_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_877" number="877" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_877_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_877"" name="XR_EXT_EXTENSION_877_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_878" number="878" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_878_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_878"" name="XR_EXT_EXTENSION_878_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_879" number="879" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_879_SPEC_VERSION"/> + <enum value=""XR_META_extension_879"" name="XR_META_EXTENSION_879_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_880" number="880" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_880_SPEC_VERSION"/> + <enum value=""XR_META_extension_880"" name="XR_META_EXTENSION_880_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_881" number="881" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_881_SPEC_VERSION"/> + <enum value=""XR_META_extension_881"" name="XR_META_EXTENSION_881_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_882" number="882" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_882_SPEC_VERSION"/> + <enum value=""XR_META_extension_882"" name="XR_META_EXTENSION_882_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_883" number="883" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_883_SPEC_VERSION"/> + <enum value=""XR_META_extension_883"" name="XR_META_EXTENSION_883_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_884" number="884" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_884_SPEC_VERSION"/> + <enum value=""XR_META_extension_884"" name="XR_META_EXTENSION_884_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_885" number="885" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_885_SPEC_VERSION"/> + <enum value=""XR_META_extension_885"" name="XR_META_EXTENSION_885_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_886" number="886" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_886_SPEC_VERSION"/> + <enum value=""XR_META_extension_886"" name="XR_META_EXTENSION_886_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_887" number="887" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_887_SPEC_VERSION"/> + <enum value=""XR_META_extension_887"" name="XR_META_EXTENSION_887_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_888" number="888" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_888_SPEC_VERSION"/> + <enum value=""XR_META_extension_888"" name="XR_META_EXTENSION_888_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_889" number="889" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_889_SPEC_VERSION"/> + <enum value=""XR_META_extension_889"" name="XR_META_EXTENSION_889_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_890" number="890" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_890_SPEC_VERSION"/> + <enum value=""XR_META_extension_890"" name="XR_META_EXTENSION_890_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_891" number="891" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_891_SPEC_VERSION"/> + <enum value=""XR_META_extension_891"" name="XR_META_EXTENSION_891_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_892" number="892" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_892_SPEC_VERSION"/> + <enum value=""XR_META_extension_892"" name="XR_META_EXTENSION_892_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_893" number="893" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_893_SPEC_VERSION"/> + <enum value=""XR_META_extension_893"" name="XR_META_EXTENSION_893_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_894" number="894" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_894_SPEC_VERSION"/> + <enum value=""XR_META_extension_894"" name="XR_META_EXTENSION_894_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_895" number="895" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_895_SPEC_VERSION"/> + <enum value=""XR_META_extension_895"" name="XR_META_EXTENSION_895_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_896" number="896" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_896_SPEC_VERSION"/> + <enum value=""XR_META_extension_896"" name="XR_META_EXTENSION_896_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_897" number="897" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_897_SPEC_VERSION"/> + <enum value=""XR_META_extension_897"" name="XR_META_EXTENSION_897_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_898" number="898" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_898_SPEC_VERSION"/> + <enum value=""XR_META_extension_898"" name="XR_META_EXTENSION_898_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_899" number="899" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_899_SPEC_VERSION"/> + <enum value=""XR_META_extension_899"" name="XR_META_EXTENSION_899_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_900" number="900" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_900_SPEC_VERSION"/> + <enum value=""XR_META_extension_900"" name="XR_META_EXTENSION_900_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_901" number="901" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_901_SPEC_VERSION"/> + <enum value=""XR_META_extension_901"" name="XR_META_EXTENSION_901_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_902" number="902" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_902_SPEC_VERSION"/> + <enum value=""XR_META_extension_902"" name="XR_META_EXTENSION_902_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_903" number="903" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_903_SPEC_VERSION"/> + <enum value=""XR_META_extension_903"" name="XR_META_EXTENSION_903_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_904" number="904" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_904_SPEC_VERSION"/> + <enum value=""XR_META_extension_904"" name="XR_META_EXTENSION_904_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_905" number="905" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_905_SPEC_VERSION"/> + <enum value=""XR_META_extension_905"" name="XR_META_EXTENSION_905_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_906" number="906" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_906_SPEC_VERSION"/> + <enum value=""XR_META_extension_906"" name="XR_META_EXTENSION_906_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_907" number="907" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_907_SPEC_VERSION"/> + <enum value=""XR_META_extension_907"" name="XR_META_EXTENSION_907_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_908" number="908" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_908_SPEC_VERSION"/> + <enum value=""XR_META_extension_908"" name="XR_META_EXTENSION_908_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_909" number="909" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_909_SPEC_VERSION"/> + <enum value=""XR_META_extension_909"" name="XR_META_EXTENSION_909_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_910" number="910" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_910_SPEC_VERSION"/> + <enum value=""XR_META_extension_910"" name="XR_META_EXTENSION_910_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_911" number="911" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_911_SPEC_VERSION"/> + <enum value=""XR_META_extension_911"" name="XR_META_EXTENSION_911_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_912" number="912" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_912_SPEC_VERSION"/> + <enum value=""XR_META_extension_912"" name="XR_META_EXTENSION_912_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_913" number="913" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_913_SPEC_VERSION"/> + <enum value=""XR_META_extension_913"" name="XR_META_EXTENSION_913_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_914" number="914" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_914_SPEC_VERSION"/> + <enum value=""XR_META_extension_914"" name="XR_META_EXTENSION_914_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_915" number="915" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_915_SPEC_VERSION"/> + <enum value=""XR_META_extension_915"" name="XR_META_EXTENSION_915_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_916" number="916" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_916_SPEC_VERSION"/> + <enum value=""XR_META_extension_916"" name="XR_META_EXTENSION_916_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_917" number="917" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_917_SPEC_VERSION"/> + <enum value=""XR_META_extension_917"" name="XR_META_EXTENSION_917_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_918" number="918" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_918_SPEC_VERSION"/> + <enum value=""XR_META_extension_918"" name="XR_META_EXTENSION_918_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_919" number="919" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_919_SPEC_VERSION"/> + <enum value=""XR_META_extension_919"" name="XR_META_EXTENSION_919_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_920" number="920" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_920_SPEC_VERSION"/> + <enum value=""XR_META_extension_920"" name="XR_META_EXTENSION_920_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_921" number="921" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_921_SPEC_VERSION"/> + <enum value=""XR_META_extension_921"" name="XR_META_EXTENSION_921_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_922" number="922" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_922_SPEC_VERSION"/> + <enum value=""XR_META_extension_922"" name="XR_META_EXTENSION_922_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_923" number="923" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_923_SPEC_VERSION"/> + <enum value=""XR_META_extension_923"" name="XR_META_EXTENSION_923_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_924" number="924" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_924_SPEC_VERSION"/> + <enum value=""XR_META_extension_924"" name="XR_META_EXTENSION_924_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_925" number="925" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_925_SPEC_VERSION"/> + <enum value=""XR_META_extension_925"" name="XR_META_EXTENSION_925_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_926" number="926" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_926_SPEC_VERSION"/> + <enum value=""XR_META_extension_926"" name="XR_META_EXTENSION_926_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_927" number="927" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_927_SPEC_VERSION"/> + <enum value=""XR_META_extension_927"" name="XR_META_EXTENSION_927_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_928" number="928" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_928_SPEC_VERSION"/> + <enum value=""XR_META_extension_928"" name="XR_META_EXTENSION_928_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_929" number="929" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_929_SPEC_VERSION"/> + <enum value=""XR_META_extension_929"" name="XR_META_EXTENSION_929_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_930" number="930" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_930_SPEC_VERSION"/> + <enum value=""XR_META_extension_930"" name="XR_META_EXTENSION_930_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_931" number="931" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_931_SPEC_VERSION"/> + <enum value=""XR_META_extension_931"" name="XR_META_EXTENSION_931_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_932" number="932" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_932_SPEC_VERSION"/> + <enum value=""XR_META_extension_932"" name="XR_META_EXTENSION_932_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_933" number="933" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_933_SPEC_VERSION"/> + <enum value=""XR_META_extension_933"" name="XR_META_EXTENSION_933_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_934" number="934" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_934_SPEC_VERSION"/> + <enum value=""XR_META_extension_934"" name="XR_META_EXTENSION_934_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_935" number="935" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_935_SPEC_VERSION"/> + <enum value=""XR_META_extension_935"" name="XR_META_EXTENSION_935_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_936" number="936" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_936_SPEC_VERSION"/> + <enum value=""XR_META_extension_936"" name="XR_META_EXTENSION_936_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_937" number="937" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_937_SPEC_VERSION"/> + <enum value=""XR_META_extension_937"" name="XR_META_EXTENSION_937_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_938" number="938" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_938_SPEC_VERSION"/> + <enum value=""XR_META_extension_938"" name="XR_META_EXTENSION_938_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_939" number="939" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_939_SPEC_VERSION"/> + <enum value=""XR_META_extension_939"" name="XR_META_EXTENSION_939_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_940" number="940" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_940_SPEC_VERSION"/> + <enum value=""XR_META_extension_940"" name="XR_META_EXTENSION_940_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_941" number="941" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_941_SPEC_VERSION"/> + <enum value=""XR_META_extension_941"" name="XR_META_EXTENSION_941_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_942" number="942" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_942_SPEC_VERSION"/> + <enum value=""XR_META_extension_942"" name="XR_META_EXTENSION_942_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_943" number="943" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_943_SPEC_VERSION"/> + <enum value=""XR_META_extension_943"" name="XR_META_EXTENSION_943_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_944" number="944" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_944_SPEC_VERSION"/> + <enum value=""XR_META_extension_944"" name="XR_META_EXTENSION_944_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_945" number="945" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_945_SPEC_VERSION"/> + <enum value=""XR_META_extension_945"" name="XR_META_EXTENSION_945_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_946" number="946" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_946_SPEC_VERSION"/> + <enum value=""XR_META_extension_946"" name="XR_META_EXTENSION_946_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_947" number="947" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_947_SPEC_VERSION"/> + <enum value=""XR_META_extension_947"" name="XR_META_EXTENSION_947_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_948" number="948" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_948_SPEC_VERSION"/> + <enum value=""XR_META_extension_948"" name="XR_META_EXTENSION_948_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_949" number="949" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_949_SPEC_VERSION"/> + <enum value=""XR_META_extension_949"" name="XR_META_EXTENSION_949_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_950" number="950" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_950_SPEC_VERSION"/> + <enum value=""XR_META_extension_950"" name="XR_META_EXTENSION_950_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_951" number="951" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_951_SPEC_VERSION"/> + <enum value=""XR_META_extension_951"" name="XR_META_EXTENSION_951_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_952" number="952" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_952_SPEC_VERSION"/> + <enum value=""XR_META_extension_952"" name="XR_META_EXTENSION_952_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_953" number="953" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_953_SPEC_VERSION"/> + <enum value=""XR_META_extension_953"" name="XR_META_EXTENSION_953_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_954" number="954" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_954_SPEC_VERSION"/> + <enum value=""XR_META_extension_954"" name="XR_META_EXTENSION_954_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_955" number="955" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_955_SPEC_VERSION"/> + <enum value=""XR_META_extension_955"" name="XR_META_EXTENSION_955_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_956" number="956" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_956_SPEC_VERSION"/> + <enum value=""XR_META_extension_956"" name="XR_META_EXTENSION_956_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_957" number="957" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_957_SPEC_VERSION"/> + <enum value=""XR_META_extension_957"" name="XR_META_EXTENSION_957_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_958" number="958" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_958_SPEC_VERSION"/> + <enum value=""XR_META_extension_958"" name="XR_META_EXTENSION_958_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_959" number="959" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_959_SPEC_VERSION"/> + <enum value=""XR_META_extension_959"" name="XR_META_EXTENSION_959_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_960" number="960" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_960_SPEC_VERSION"/> + <enum value=""XR_META_extension_960"" name="XR_META_EXTENSION_960_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_961" number="961" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_961_SPEC_VERSION"/> + <enum value=""XR_META_extension_961"" name="XR_META_EXTENSION_961_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_962" number="962" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_962_SPEC_VERSION"/> + <enum value=""XR_META_extension_962"" name="XR_META_EXTENSION_962_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_963" number="963" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_963_SPEC_VERSION"/> + <enum value=""XR_META_extension_963"" name="XR_META_EXTENSION_963_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_964" number="964" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_964_SPEC_VERSION"/> + <enum value=""XR_META_extension_964"" name="XR_META_EXTENSION_964_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_965" number="965" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_965_SPEC_VERSION"/> + <enum value=""XR_META_extension_965"" name="XR_META_EXTENSION_965_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_966" number="966" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_966_SPEC_VERSION"/> + <enum value=""XR_META_extension_966"" name="XR_META_EXTENSION_966_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_967" number="967" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_967_SPEC_VERSION"/> + <enum value=""XR_META_extension_967"" name="XR_META_EXTENSION_967_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_968" number="968" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_968_SPEC_VERSION"/> + <enum value=""XR_META_extension_968"" name="XR_META_EXTENSION_968_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_969" number="969" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_969_SPEC_VERSION"/> + <enum value=""XR_META_extension_969"" name="XR_META_EXTENSION_969_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_970" number="970" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_970_SPEC_VERSION"/> + <enum value=""XR_META_extension_970"" name="XR_META_EXTENSION_970_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_971" number="971" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_971_SPEC_VERSION"/> + <enum value=""XR_META_extension_971"" name="XR_META_EXTENSION_971_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_972" number="972" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_972_SPEC_VERSION"/> + <enum value=""XR_META_extension_972"" name="XR_META_EXTENSION_972_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_973" number="973" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_973_SPEC_VERSION"/> + <enum value=""XR_META_extension_973"" name="XR_META_EXTENSION_973_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_974" number="974" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_974_SPEC_VERSION"/> + <enum value=""XR_META_extension_974"" name="XR_META_EXTENSION_974_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_975" number="975" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_975_SPEC_VERSION"/> + <enum value=""XR_META_extension_975"" name="XR_META_EXTENSION_975_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_976" number="976" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_976_SPEC_VERSION"/> + <enum value=""XR_META_extension_976"" name="XR_META_EXTENSION_976_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_977" number="977" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_977_SPEC_VERSION"/> + <enum value=""XR_META_extension_977"" name="XR_META_EXTENSION_977_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_978" number="978" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_978_SPEC_VERSION"/> + <enum value=""XR_META_extension_978"" name="XR_META_EXTENSION_978_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_979" number="979" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_979_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_979"" name="XR_EXT_EXTENSION_979_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_980" number="980" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_980_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_980"" name="XR_ANDROID_EXTENSION_980_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_981" number="981" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_981_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_981"" name="XR_ANDROID_EXTENSION_981_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_982" number="982" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_982_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_982"" name="XR_ANDROID_EXTENSION_982_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_983" number="983" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_983_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_983"" name="XR_ANDROID_EXTENSION_983_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_984" number="984" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_984_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_984"" name="XR_ANDROID_EXTENSION_984_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_985" number="985" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_985_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_985"" name="XR_ANDROID_EXTENSION_985_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_986" number="986" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_986_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_986"" name="XR_ANDROID_EXTENSION_986_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_987" number="987" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_987_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_987"" name="XR_ANDROID_EXTENSION_987_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_988" number="988" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_988_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_988"" name="XR_ANDROID_EXTENSION_988_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_989" number="989" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_989_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_989"" name="XR_ANDROID_EXTENSION_989_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_990" number="990" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_990_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_990"" name="XR_ANDROID_EXTENSION_990_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_991" number="991" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_991_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_991"" name="XR_ANDROID_EXTENSION_991_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_992" number="992" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_992_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_992"" name="XR_ANDROID_EXTENSION_992_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_993" number="993" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_993_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_993"" name="XR_ANDROID_EXTENSION_993_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_994" number="994" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_994_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_994"" name="XR_ANDROID_EXTENSION_994_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_995" number="995" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_995_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_995"" name="XR_ANDROID_EXTENSION_995_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_996" number="996" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_996_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_996"" name="XR_ANDROID_EXTENSION_996_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_997" number="997" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_997_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_997"" name="XR_ANDROID_EXTENSION_997_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_998" number="998" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_998_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_998"" name="XR_ANDROID_EXTENSION_998_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_999" number="999" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_999_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_999"" name="XR_ANDROID_EXTENSION_999_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_1000" number="1000" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_1000_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_1000"" name="XR_ANDROID_EXTENSION_1000_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_1001" number="1001" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_1001_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_1001"" name="XR_ANDROID_EXTENSION_1001_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_1002" number="1002" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_1002_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_1002"" name="XR_ANDROID_EXTENSION_1002_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_1003" number="1003" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_1003_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_1003"" name="XR_ANDROID_EXTENSION_1003_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_1004" number="1004" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_1004_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_1004"" name="XR_ANDROID_EXTENSION_1004_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_1005" number="1005" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_1005_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_1005"" name="XR_ANDROID_EXTENSION_1005_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_1006" number="1006" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_1006_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_1006"" name="XR_ANDROID_EXTENSION_1006_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_1007" number="1007" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_1007_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_1007"" name="XR_ANDROID_EXTENSION_1007_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_1008" number="1008" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_1008_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_1008"" name="XR_ANDROID_EXTENSION_1008_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_1009" number="1009" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_1009_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_1009"" name="XR_ANDROID_EXTENSION_1009_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_1010" number="1010" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_1010_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_1010"" name="XR_ANDROID_EXTENSION_1010_EXTENSION_NAME"/> + </require> + </extension> + + </extensions> + +</registry> diff --git a/shadps4-arm64-main/externals/openxr-sdk/specification/registry/xr.xml b/shadps4-arm64-main/externals/openxr-sdk/specification/registry/xr.xml new file mode 100644 index 0000000..2d6b9c8 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/specification/registry/xr.xml @@ -0,0 +1,25964 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE registry> +<?xml-model href="registry.rnc" type="application/relax-ng-compact-syntax"?> +<?xml-model href="registry.sch" type="application/xml" schematypens="http://purl.oclc.org/dsdl/schematron"?> +<registry> + <!-- + DO NOT EDIT DIRECTLY - generated from xr.fragmented.xml and the following fragments: + + - fragments/android/XR_ANDROID_trackables.xml + - fragments/ext/XR_EXT_spatial_container.xml + - fragments/ext/XR_EXT_spatial_container_self_rendering.xml + - fragments/ext/XR_EXT_spatial_image_tracking.xml + - fragments/khr/XR_KHR_extended_result_name_lengths.xml +--> + <comment> +Copyright (c) 2017-2026 The Khronos Group Inc. + +SPDX-License-Identifier: Apache-2.0 OR MIT + +------------------------------------------------------------------------ + +This file, xr.xml, is the OpenXR API Registry. It is a critically important +and normative part of the OpenXR Specification, including a canonical +machine-readable definition of the API, parameter and member validation +language incorporated into the Specification and reference pages, and other +material which is registered by Khronos, such as tags used by extension and +layer authors. The only authoritative version of xr.xml is the one +maintained in the default branch of the Khronos OpenXR GitHub project. + </comment> + + <!-- SECTION: OpenXR vendor IDs for physical devices without USB vendor IDs --> + <vendorids> + <vendorid name="MND" id="0x10001" comment="Monado Project vendor ID"/> + <vendorid name="KHR" id="0x10002" comment="This is the next available Khronos vendor ID"/> + </vendorids> + + <!-- SECTION: OpenXR vendor/author tags for extensions and layers --> + <tags> + <!-- Sorted alphabetically by tag name --> + <tag name="ACER" author="Acer" contact="OC Lin @aceroc"/> + <tag name="ALMALENCE" author="Almalence" contact="Ivan Chupakhin @ivan.chupakhin, Dmitry Shmunk @dmitry.shmunk"/> + <tag name="ANDROID" author="Google" contact="Nihav Jain @njain_google"/> + <tag name="ANDROIDSYS" author="Google" contact="Nihav Jain @njain_google"/> + <tag name="ARM" author="Arm Limited" contact="Andreas Loeve Selvik @selvik, Sam Martin @sammartin"/> + <tag name="BD" author="ByteDance" contact="Will Fu @willfu, Bangsen Han @Hansenn"/> + <tag name="COLLABORA" author="Collabora" contact="Rylie Pavlik @rpavlik"/> + <tag name="DANWILLM" author="Daniel Willmott" contact="Daniel Willmott @danwillm"/> + <tag name="DEEPMIRROR" author="Deep Mirror" contact="Yuhui Lun @lyh-dm"/> + <tag name="DXR" author="The DisplayXR Project" contact="David Fattal @dfattal"/> + <tag name="EPIC" author="Epic" contact="Nick Whiting @whitingn"/> + <tag name="EXT" author="Multivendor" contact="Rylie Pavlik @rpavlik"/> + <tag name="FB" author="Facebook" contact="Cass Everitt @casseveritt, Jonathan Wright @Nelno"/> + <tag name="FREDEMMOTT" author="Frederick Emmott" contact="Frederick Emmott @fredemmott"/> + <tag name="GOOGLE" author="Google" contact="Kaye Mason @chaleur"/> + <tag name="HOLOLIGHT" author="Holo-Light GmbH" contact="Aidan Howie @aidanhowie, Krzysztof Lesiak @k_lesiak"/> + <tag name="HTC" author="HTC" contact="Chris Kuo @ggkuo, Kyle Chen @kylechen76"/> + <tag name="HUAWEI" author="Huawei" contact="Yihong Huang @rachelhuang, Li jingya @yzljy"/> + <tag name="INTEL" author="Intel" contact="Javier Martinez @javier"/> + <tag name="KHR" author="Khronos" contact="Brent Insko @insko"/> + <tag name="LEIA" author="Leia" contact="Cristina Scheibler @cscheibler"/> + <tag name="LUNARG" author="LunarG" contact="Brad Grantham @bradgrantham-lunarg"/> + <tag name="LIV" author="LIV" contact="Arthur Brainville @Ybalrid, Steffan Donal @liv_ruu"/> + <tag name="LOGITECH" author="Logitech" contact="Mario Gutierrez @mgutierrez1, Fabien Zellweger @fzellweger"/> + <tag name="META" author="Meta Platforms" contact="Cass Everitt @casseveritt, Jonathan Wright @Nelno"/> + <tag name="ML" author="Magic Leap" contact="Ron Bessems @rbessems"/> + <tag name="MND" author="Monado Project" contact="Jakob Bornecrantz @wallbraker, Rylie Pavlik @rpavlik"/> + <tag name="MSFT" author="Microsoft" contact="Alex Turner @alexturn, Yin Li @yl_msft, Bryce Hutchings @brycehutchings, Lachlan Ford @laford_msft, Minmin Gong @gongminmin "/> + <tag name="NV" author="NVIDIA Corporation" contact="Satish Salian @ssalian, Robert Menzel"/> + <tag name="OCULUS" author="Oculus" contact="Cass Everitt @casseveritt, Jonathan Wright @Nelno"/> + <tag name="OPPO" author="OPPO" contact="Buyi Xu @fantastxu, Haomiao Jiang @hjiang36"/> + <tag name="PLUTO" author="Pluto VR" contact="Jared Cheshier @Jared, Sophia Baldonado @sophia"/> + <tag name="QCOM" author="Qualcomm Technologies" contact="Armelle @alaine_qcom, Martin Renschler @martinr"/> + <tag name="RZR" author="Razer" contact="Alexandre Hulsken @ahulsken, Eric Vezzoli @EricVezzoli"/> + <tag name="SONY" author="Sony Corporation" contact="Kota Suzuki @kotasuzuki"/> + <tag name="STARBREEZE" author="Starbreeze" contact="David Srour @dsrour"/> + <tag name="TOBII" author="Tobii" contact="Denny Rönngren @denron"/> + <tag name="ULTRALEAP" author="Ultraleap" contact="Robert Blenkinsopp @rblenkinsopp"/> + <tag name="UNITY" author="Unity Technologies" contact="Jack Pritz @jackpritz, Peter Kuhn @peterunity"/> + <tag name="VALVE" author="Valve" contact="Joe Ludwig @JoeLudwig"/> + <tag name="VARJO" author="Varjo" contact="Denny Rönngren @denron_varjo"/> + <tag name="YVR" author="YVR" contact="Pengpeng Zhang @zhangpengpeng"/> + </tags> + + <!-- SECTION: OpenXR type definitions --> + <types> + <type name="openxr_platform_defines" category="include">#include "openxr_platform_defines.h"</type> + + <type requires="android/binder_ibinder.h" name="AIBinder"/> + <type requires="android/native_window.h" name="ANativeWindow"/> + <type requires="jni.h" name="jobject"/> + <type requires="CL/cl_gl_ext.h" name="CGLContextObj"/> + <type requires="d3dcommon.h" name="D3D_FEATURE_LEVEL"/> + <type requires="D3D11.h" name="ID3D11Device"/> + <type requires="D3D11.h" name="ID3D11Texture2D"/> + <type requires="D3D12.h" name="ID3D12CommandQueue"/> + <type requires="D3D12.h" name="ID3D12Device"/> + <type requires="D3D12.h" name="ID3D12Resource"/> + <type requires="EGL/egl.h" name="EGLDisplay"/> + <type requires="EGL/egl.h" name="EGLConfig"/> + <type requires="EGL/egl.h" name="EGLContext"/> + <type requires="EGL/egl.h" name="EGLenum"/> + <type requires="GL/glxext.h" name="GLXFBConfig"/> + <type requires="GL/glxext.h" name="GLXDrawable"/> + <type requires="GL/glxext.h" name="GLXContext"/> + <type requires="GL/wglext.h" name="HGLRC"/> + <type requires="unknwn.h" name="IUnknown"/> + <type requires="wayland-client.h" name="wl_display"/> + <type requires="windows.h" name="HDC"/> + <type requires="windows.h" name="LUID"/> + <type requires="windows.h" name="LARGE_INTEGER"/> + <type requires="X11/Xlib.h" name="Display"/> + <type requires="X11/Xlib.h" name="VisualID"/> + <type requires="X11/Xlib.h" name="Window"/> + <type requires="xcb/glx.h" name="xcb_glx_fbconfig_t"/> + <type requires="xcb/glx.h" name="xcb_glx_drawable_t"/> + <type requires="xcb/glx.h" name="xcb_glx_context_t"/> + <type requires="xcb/xcb.h" name="xcb_connection_t"/> + <type requires="xcb/xcb.h" name="xcb_visualid_t"/> + <type requires="xcb/xcb.h" name="xcb_window_t"/> + <type requires="vulkan/vulkan.h" name="PFN_vkGetInstanceProcAddr"/> + <type requires="vulkan/vulkan.h" name="VkAllocationCallbacks"/> + <type requires="vulkan/vulkan.h" name="VkComponentSwizzle"/> + <type requires="vulkan/vulkan.h" name="VkDevice"/> + <type requires="vulkan/vulkan.h" name="VkDeviceCreateInfo"/> + <type requires="vulkan/vulkan.h" name="VkFilter"/> + <type requires="vulkan/vulkan.h" name="VkFormat"/> + <type requires="vulkan/vulkan.h" name="VkImage"/> + <type requires="vulkan/vulkan.h" name="VkImageCreateFlags"/> + <type requires="vulkan/vulkan.h" name="VkImageUsageFlags"/> + <type requires="vulkan/vulkan.h" name="VkInstance"/> + <type requires="vulkan/vulkan.h" name="VkInstanceCreateInfo"/> + <type requires="vulkan/vulkan.h" name="VkPhysicalDevice"/> + <type requires="vulkan/vulkan.h" name="VkResult"/> + <type requires="vulkan/vulkan.h" name="VkSamplerAddressMode"/> + <type requires="vulkan/vulkan.h" name="VkSamplerMipmapMode"/> + <type requires="time.h" name="timespec"/> + <type requires="ml_coordinate_frame_uid.h" name="MLCoordinateFrameUID"/> + + <type category="define">#define <name>XR_MAKE_VERSION</name>(major, minor, patch) \ + ((((major) & 0xffffULL) << 48) | (((minor) & 0xffffULL) << 32) | ((patch) & 0xffffffffULL))</type> + <type category="define">#define <name>XR_VERSION_MAJOR</name>(version) (uint16_t)(((uint64_t)(version) >> 48)& 0xffffULL)</type> + <type category="define">#define <name>XR_VERSION_MINOR</name>(version) (uint16_t)(((uint64_t)(version) >> 32) & 0xffffULL)</type> + <type category="define">#define <name>XR_VERSION_PATCH</name>(version) (uint32_t)((uint64_t)(version) & 0xffffffffULL)</type> + + <!-- + NOTE: The following group of lines defining the two version constants + must not be re-arranged or re-flowed, since scripts/update_version.py + updates them automatically by processing a line at a time. + --> + <type category="define">// OpenXR current version number. +#define <name>XR_CURRENT_API_VERSION</name> <type>XR_MAKE_VERSION</type>(1, 1, 63)</type> + + <!-- + Defines for a fixed major.minor version of OpenXR preserving the shared patch version. + --> + <type category="define">// OpenXR 1.0 version number +#define <name>XR_API_VERSION_1_0</name> <type>XR_MAKE_VERSION</type>(1, 0, XR_VERSION_PATCH(XR_CURRENT_API_VERSION))</type> + + <type category="define">// OpenXR 1.1 version number +#define <name>XR_API_VERSION_1_1</name> <type>XR_MAKE_VERSION</type>(1, 1, XR_VERSION_PATCH(XR_CURRENT_API_VERSION))</type> + + <!-- + NOTE: For avoidance of ambiguity, there should only be 1 <name> tag immediately in + each <type>. This is why XR_MAY_ALIAS appears multiple times below, but only once with + the <name> tags wrapping it. It does not particularly matter which of the copies of + names gets marked up, but it seems reasonable that the most meaningful one is marked up. + --> + <type category="define"> +#if !defined(XR_MAY_ALIAS) +#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4)) +#define <name>XR_MAY_ALIAS</name> __attribute__((__may_alias__)) +#else +#define XR_MAY_ALIAS +#endif +#endif</type> + + <type category="define"> +#if !defined(XR_DEFINE_HANDLE) +#if (XR_PTR_SIZE == 8) + #define <name>XR_DEFINE_HANDLE</name>(object) typedef struct object##_T* object; +#else + #define XR_DEFINE_HANDLE(object) typedef uint64_t object; +#endif +#endif</type> + + <type category="define"> +#if !defined(XR_NULL_HANDLE) +#if (XR_PTR_SIZE == 8) && XR_CPP_NULLPTR_SUPPORTED + #define <name>XR_NULL_HANDLE</name> nullptr +#else + #define XR_NULL_HANDLE 0 +#endif +#endif</type> + + <type category="define"> +#if !defined(XR_DEFINE_ATOM) + #define <name>XR_DEFINE_ATOM</name>(object) typedef uint64_t object; +#endif</type> + + <type category="define"> +#if !defined(XR_DEFINE_OPAQUE_64) + #if (XR_PTR_SIZE == 8) + #define <name>XR_DEFINE_OPAQUE_64</name>(object) typedef struct object##_T* object; + #else + #define XR_DEFINE_OPAQUE_64(object) typedef uint64_t object; + #endif +#endif</type> + + <type category="define"> +#define <name>XR_EXTENSION_ENUM_BASE</name> 1000000000</type> + + <type category="define"> +#define <name>XR_EXTENSION_ENUM_STRIDE</name> 1000</type> + + <type category="define"> +#define <name>XR_NULL_PATH</name> 0</type> + + <type category="define"> +#define <name>XR_NULL_SYSTEM_ID</name> 0</type> + + <type category="define"> +#define <name>XR_SUCCEEDED</name>(result) ((result) >= 0)</type> + + <type category="define"> +#define <name>XR_UNQUALIFIED_SUCCESS</name>(result) ((result) == 0)</type> + + <type category="define"> +#define <name>XR_FAILED</name>(result) ((result) < 0)</type> + + <type category="define"> +#define <name>XR_NO_DURATION</name> 0</type> + + <type category="define"> +#define <name>XR_INFINITE_DURATION</name> 0x7fffffffffffffffLL</type> + + <type category="define"> +#define <name>XR_MIN_HAPTIC_DURATION</name> -1</type> + + <type category="define"> +#define <name>XR_FREQUENCY_UNSPECIFIED</name> 0</type> + + <type category="define"> +#define <name>XR_MAX_EVENT_DATA_SIZE</name> sizeof(XrEventDataBuffer)</type> + + <type category="define"> +#define <name>XR_MIN_COMPOSITION_LAYERS_SUPPORTED</name> 16</type> + + <!-- openxr_loader_negotiation.h --> + <type category="define"> +#define <name>XR_CURRENT_LOADER_API_LAYER_VERSION</name> 1</type> + <type category="define"> +#define <name>XR_CURRENT_LOADER_RUNTIME_VERSION</name> 1</type> + <type category="define"> +#define <name>XR_LOADER_INFO_STRUCT_VERSION</name> 1</type> + <type category="define"> +#define <name>XR_API_LAYER_INFO_STRUCT_VERSION</name> 1</type> + <type category="define"> +#define <name>XR_RUNTIME_INFO_STRUCT_VERSION</name> 1</type> + <type category="define"> +#define <name>XR_API_LAYER_NEXT_INFO_STRUCT_VERSION</name> 1</type> + <type category="define"> +#define <name>XR_API_LAYER_CREATE_INFO_STRUCT_VERSION</name> 1</type> + <type category="define"> +#define <name>XR_API_LAYER_MAX_SETTINGS_PATH_SIZE</name> 512</type> + + <!-- XR_EXT_hand_tracking --> + <type category="define"> +#define <name>XR_HAND_JOINT_COUNT_EXT</name> 26</type> + + <!-- XR_BD_body_tracking --> + <type category="define"> +#define <name>XR_BODY_JOINT_COUNT_BD</name> 24</type> + <type category="define"> +#define <name>XR_BODY_JOINT_WITHOUT_ARM_COUNT_BD</name> 16</type> + + <!-- XR_MSFT_controller_model --> + <type category="define"> +#define <name>XR_NULL_CONTROLLER_MODEL_KEY_MSFT</name> 0</type> + + <!-- XR_FB_render_model --> + <type category="define"> +#define <name>XR_NULL_RENDER_MODEL_KEY_FB</name> 0</type> + + <!-- XR_HTC_facial_tracking --> + <type category="define"> +#define <name>XR_FACIAL_EXPRESSION_EYE_COUNT_HTC</name> 14</type> + <type category="define"> +#define <name>XR_FACIAL_EXPRESSION_LIP_COUNT_HTC</name> 37</type> + + <!-- XR_ULTRALEAP_hand_tracking_forearm --> + <type category="define"> +#define <name>XR_HAND_FOREARM_JOINT_COUNT_ULTRALEAP</name> 27</type> + + <!-- XR_FB_face_tracking --> + <type category="define"> +#define <name>XR_FACE_EXPRESSSION_SET_DEFAULT_FB</name> XR_FACE_EXPRESSION_SET_DEFAULT_FB</type> + + <!-- XR_FB_haptic_amplitude_envelope --> + <type category="define"> +#define <name>XR_MAX_HAPTIC_AMPLITUDE_ENVELOPE_SAMPLES_FB</name> 4000u</type> + + <!-- XR_FB_haptic_pcm --> + <type category="define"> +#define <name>XR_MAX_HAPTIC_PCM_BUFFER_SIZE_FB</name> 4000</type> + + <!-- XR_EXT_spatial_entity --> + <type category="define"> +#define <name>XR_NULL_SPATIAL_ENTITY_ID_EXT</name> 0</type> + + <type category="define"> +#define <name>XR_NULL_SPATIAL_BUFFER_ID_EXT</name> 0</type> + + <!-- XR_HTC_body_tracking --> + <type category="define"> +#define <name>XR_BODY_JOINT_COUNT_HTC</name> 26</type> + + <!-- XR_BD_facial_simulation--> + <type category="define"> +#define <name>XR_FACE_EXPRESSION_COUNT_BD</name> 52</type> + <type category="define"> +#define <name>XR_LIP_EXPRESSION_COUNT_BD</name> 20</type> + + + <!-- XR_EXT_haptic_parametric --> + <type category="define"> +#define <name>XR_HAPTIC_PARAMETRIC_MAX_POINTS_TRANSIENTS_EXT</name> 500</type> + <type category="define"> +#define <name>XR_HAPTIC_PARAMETRIC_VIBRATION_EXTEND_DURATION_EXT</name> 50000000</type> + <type category="define"> +#define <name>XR_HAPTIC_PARAMETRIC_FREQUENCY_MIN_HZ_EXT</name> 1</type> + <type category="define"> +#define <name>XR_HAPTIC_PARAMETRIC_FREQUENCY_MAX_HZ_EXT</name> 1000</type> + + <!-- Value types --> + <type category="basetype">typedef <type>uint32_t</type> <name>XrBool32</name>;</type> + <type category="basetype">typedef <type>uint64_t</type> <name>XrFlags64</name>;</type> + <type category="basetype">typedef <type>int64_t</type> <name>XrTime</name>;</type> + <type category="basetype">typedef <type>int64_t</type> <name>XrDuration</name>;</type> + <type category="basetype">typedef <type>uint64_t</type> <name>XrVersion</name>;</type> + + <!-- XR_FB_spatial_entity_user --> + <type category="basetype">typedef <type>uint64_t</type> <name>XrSpaceUserIdFB</name>;</type> + + <!-- Atoms, allocated by the runtime (if implementation requires) and never freed --> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrPath</name>)</type> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrSystemId</name>)</type> + <!-- XR_MSFT_controller_model --> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrControllerModelKeyMSFT</name>)</type> + <!-- XR_FB_spatial_entity --> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrAsyncRequestIdFB</name>)</type> + <!-- XR_FB_render_model --> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrRenderModelKeyFB</name>)</type> + <!-- XR_ML_marker_understanding --> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrMarkerML</name>)</type> + <!-- XR_EXT_render_model --> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrRenderModelIdEXT</name>)</type> + <!-- XR_EXT_spatial_entity --> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrSpatialEntityIdEXT</name>)</type> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrSpatialBufferIdEXT</name>)</type> + + <!-- Basic C types, pulled in via openxr_platform_defines.h --> + <type requires="openxr_platform_defines" name="void"/> + <type requires="openxr_platform_defines" name="char"/> + <type requires="openxr_platform_defines" name="wchar_t"/> + <type requires="openxr_platform_defines" name="float"/> + <type requires="openxr_platform_defines" name="int8_t"/> + <type requires="openxr_platform_defines" name="uint8_t"/> + <type requires="openxr_platform_defines" name="int16_t"/> + <type requires="openxr_platform_defines" name="uint16_t"/> + <type requires="openxr_platform_defines" name="int32_t"/> + <type requires="openxr_platform_defines" name="uint32_t"/> + <type requires="openxr_platform_defines" name="int64_t"/> + <type requires="openxr_platform_defines" name="uint64_t"/> + <type requires="openxr_platform_defines" name="size_t"/> + <type requires="openxr_platform_defines" name="uintptr_t"/> + + <!-- XR_KHR_maintenance1 --> + <type requires="openxr_platform_defines" name="double"/> + + <!-- Bitmask types --> + <type bitvalues="XrInstanceCreateFlagBits" category="bitmask">typedef <type>XrFlags64</type> <name>XrInstanceCreateFlags</name>;</type> + <type bitvalues="XrSessionCreateFlagBits" category="bitmask">typedef <type>XrFlags64</type> <name>XrSessionCreateFlags</name>;</type> + <type bitvalues="XrSwapchainCreateFlagBits" category="bitmask">typedef <type>XrFlags64</type> <name>XrSwapchainCreateFlags</name>;</type> + <type bitvalues="XrSwapchainUsageFlagBits" category="bitmask">typedef <type>XrFlags64</type> <name>XrSwapchainUsageFlags</name>;</type> + <type bitvalues="XrViewStateFlagBits" category="bitmask">typedef <type>XrFlags64</type> <name>XrViewStateFlags</name>;</type> + <type bitvalues="XrCompositionLayerFlagBits" category="bitmask">typedef <type>XrFlags64</type> <name>XrCompositionLayerFlags</name>;</type> + <type bitvalues="XrSpaceLocationFlagBits" category="bitmask">typedef <type>XrFlags64</type> <name>XrSpaceLocationFlags</name>;</type> + <type bitvalues="XrSpaceVelocityFlagBits" category="bitmask">typedef <type>XrFlags64</type> <name>XrSpaceVelocityFlags</name>;</type> + <type bitvalues="XrInputSourceLocalizedNameFlagBits" category="bitmask">typedef <type>XrFlags64</type> <name>XrInputSourceLocalizedNameFlags</name>;</type> + + <!-- Bitmask types for XR_KHR_vulkan_enable2 --> + <type bitvalues="XrVulkanInstanceCreateFlagBitsKHR" category="bitmask">typedef <type>XrFlags64</type> <name>XrVulkanInstanceCreateFlagsKHR</name>;</type> + <type bitvalues="XrVulkanDeviceCreateFlagBitsKHR" category="bitmask">typedef <type>XrFlags64</type> <name>XrVulkanDeviceCreateFlagsKHR</name>;</type> + + <!-- Bitmask types for XR_EXT_debug_utils --> + <type bitvalues="XrDebugUtilsMessageSeverityFlagBitsEXT" category="bitmask">typedef <type>XrFlags64</type> <name>XrDebugUtilsMessageSeverityFlagsEXT</name>;</type> + <type bitvalues="XrDebugUtilsMessageTypeFlagBitsEXT" category="bitmask">typedef <type>XrFlags64</type> <name>XrDebugUtilsMessageTypeFlagsEXT</name>;</type> + + <!-- Bitmask types for XR_EXT_frame_synthesis --> + <type bitvalues="XrFrameSynthesisInfoFlagBitsEXT" category="bitmask">typedef <type>XrFlags64</type> <name>XrFrameSynthesisInfoFlagsEXT</name>;</type> + + <!-- Bitmask types for XR_EXTX_overlay --> + <type bitvalues="XrOverlayMainSessionFlagBitsEXTX" category="bitmask">typedef <type>XrFlags64</type> <name>XrOverlayMainSessionFlagsEXTX</name>;</type> + <type bitvalues="XrOverlaySessionCreateFlagBitsEXTX" category="bitmask">typedef <type>XrFlags64</type> <name>XrOverlaySessionCreateFlagsEXTX</name>;</type> + + <!-- Bitmask types for XR_FB_android_surface_swapchain_create --> + <type bitvalues="XrAndroidSurfaceSwapchainFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrAndroidSurfaceSwapchainFlagsFB</name>;</type> + + <!-- Bitmask types for XR_FB_composition_layer_image_layout --> + <type bitvalues="XrCompositionLayerImageLayoutFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrCompositionLayerImageLayoutFlagsFB</name>;</type> + + <!-- Bitmask types for XR_FB_composition_layer_secure_content --> + <type bitvalues="XrCompositionLayerSecureContentFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrCompositionLayerSecureContentFlagsFB</name>;</type> + + <!-- Bitmask types for XR_FB_foveation --> + <type bitvalues="XrSwapchainCreateFoveationFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrSwapchainCreateFoveationFlagsFB</name>;</type> + <type bitvalues="XrSwapchainStateFoveationFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrSwapchainStateFoveationFlagsFB</name>;</type> + + <!-- Bitmask types for XR_META_foveation_eye_tracked --> + <type bitvalues="XrFoveationEyeTrackedProfileCreateFlagBitsMETA" category="bitmask">typedef <type>XrFlags64</type> <name>XrFoveationEyeTrackedProfileCreateFlagsMETA</name>;</type> + <type bitvalues="XrFoveationEyeTrackedStateFlagBitsMETA" category="bitmask">typedef <type>XrFlags64</type> <name>XrFoveationEyeTrackedStateFlagsMETA</name>;</type> + + <!-- Bitmask types for XR_FB_triangle_mesh --> + <type bitvalues="XrTriangleMeshFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrTriangleMeshFlagsFB</name>;</type> + + <!-- Bitmask types for XR_FB_passthrough --> + <type bitvalues="XrPassthroughFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrPassthroughFlagsFB</name>;</type> + <type bitvalues="XrPassthroughStateChangedFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrPassthroughStateChangedFlagsFB</name>;</type> + <type bitvalues="XrPassthroughCapabilityFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrPassthroughCapabilityFlagsFB</name>;</type> + + <!-- Bitmask types for XR_FB_scene --> + <type bitvalues="XrSemanticLabelsSupportFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrSemanticLabelsSupportFlagsFB</name>;</type> + + <!-- Bitmask types for XR_FB_hand_tracking_aim --> + <type bitvalues="XrHandTrackingAimFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrHandTrackingAimFlagsFB</name>;</type> + + <!-- Bitmask types for XR_BD_body_tracking_auxiliary_metrics --> + <type bitvalues="XrSpaceAccelerationFlagBitsBD" category="bitmask">typedef <type>XrFlags64</type> <name>XrSpaceAccelerationFlagsBD</name>;</type> + + <!-- Bitmask types for XR_FB_keyboard_tracking --> + <type bitvalues="XrKeyboardTrackingFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrKeyboardTrackingFlagsFB</name>;</type> + <type bitvalues="XrKeyboardTrackingQueryFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrKeyboardTrackingQueryFlagsFB</name>;</type> + + <!-- Bitmask types for XR_FB_space_warp --> + <type bitvalues="XrCompositionLayerSpaceWarpInfoFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrCompositionLayerSpaceWarpInfoFlagsFB</name>;</type> + + <!-- Bitmask types for XR_FB_render_model --> + <type bitvalues="XrRenderModelFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrRenderModelFlagsFB</name>;</type> + + <!-- Bitmask types for XR_ALMALENCE_digital_lens_control --> + <type bitvalues="XrDigitalLensControlFlagBitsALMALENCE" category="bitmask">typedef <type>XrFlags64</type> <name>XrDigitalLensControlFlagsALMALENCE</name>;</type> + + <!-- Bitmask types for XR_FB_composition_layer_settings --> + <type bitvalues="XrCompositionLayerSettingsFlagBitsFB" category="bitmask">typedef <type>XrFlags64</type> <name>XrCompositionLayerSettingsFlagsFB</name>;</type> + + <!-- Bitmask types for XR_OCULUS_external_camera --> + <type bitvalues="XrExternalCameraStatusFlagBitsOCULUS" category="bitmask">typedef <type>XrFlags64</type> <name>XrExternalCameraStatusFlagsOCULUS</name>;</type> + + <!-- Bitmask types for XR_META_performance_metrics --> + <type bitvalues="XrPerformanceMetricsCounterFlagBitsMETA" category="bitmask">typedef <type>XrFlags64</type> <name>XrPerformanceMetricsCounterFlagsMETA</name>;</type> + + <!-- Bitmask types for XR_META_passthrough_preferences --> + <type bitvalues="XrPassthroughPreferenceFlagBitsMETA" category="bitmask">typedef <type>XrFlags64</type> <name>XrPassthroughPreferenceFlagsMETA</name>;</type> + + <!-- Bitmask types for XR_HTC_foveation --> + <type bitvalues="XrFoveationDynamicFlagBitsHTC" category="bitmask">typedef <type>XrFlags64</type> <name>XrFoveationDynamicFlagsHTC</name>;</type> + + <!-- enums for XR_ANDROID_passthrough_camera_state --> + <type name="XrPassthroughCameraStateANDROID" category="enum"/> + + <!-- Bitmask types for XR_ANDROID_performance_metrics --> + <type bitvalues="XrPerformanceMetricsCounterFlagBitsANDROID" category="bitmask">typedef <type>XrFlags64</type> <name>XrPerformanceMetricsCounterFlagsANDROID</name>;</type> + + <!-- Bitmask types for XR_ML_frame_end_info --> + <type bitvalues="XrFrameEndInfoFlagBitsML" category="bitmask">typedef <type>XrFlags64</type> <name>XrFrameEndInfoFlagsML</name>;</type> + + <!-- Bitmask types for XR_ML_global_dimmer --> + <type bitvalues="XrGlobalDimmerFrameEndInfoFlagBitsML" category="bitmask">typedef <type>XrFlags64</type> <name>XrGlobalDimmerFrameEndInfoFlagsML</name>;</type> + + <!-- Bitmask types for XR_EXT_plane_detection --> + <type bitvalues="XrPlaneDetectorFlagBitsEXT" category="bitmask">typedef <type>XrFlags64</type> <name>XrPlaneDetectorFlagsEXT</name>;</type> + <type bitvalues="XrPlaneDetectionCapabilityFlagBitsEXT" category="bitmask">typedef <type>XrFlags64</type> <name>XrPlaneDetectionCapabilityFlagsEXT</name>;</type> + + <!-- Bitmask types for XR_META_virtual_keyboard --> + <type bitvalues="XrVirtualKeyboardInputStateFlagBitsMETA" category="bitmask">typedef <type>XrFlags64</type> <name>XrVirtualKeyboardInputStateFlagsMETA</name>;</type> + + <!-- Bitmask types for XR_ML_localization_map --> + <type bitvalues="XrLocalizationMapErrorFlagBitsML" category="bitmask">typedef <type>XrFlags64</type> <name>XrLocalizationMapErrorFlagsML</name>;</type> + + <!-- Bitmask types for XR_META_environment_depth --> + <type bitvalues="XrEnvironmentDepthProviderCreateFlagBitsMETA" category="bitmask">typedef <type>XrFlags64</type> <name>XrEnvironmentDepthProviderCreateFlagsMETA</name>;</type> + <type bitvalues="XrEnvironmentDepthSwapchainCreateFlagBitsMETA" category="bitmask">typedef <type>XrFlags64</type> <name>XrEnvironmentDepthSwapchainCreateFlagsMETA</name>;</type> + + <!-- XR_ML_world_mesh_detection --> + <type bitvalues="XrWorldMeshDetectorFlagBitsML" category="bitmask">typedef <type>XrFlags64</type> <name>XrWorldMeshDetectorFlagsML</name>;</type> + + <!-- XR_BD_spatial_audio_rendering --> + <type bitvalues="XrSoundObstacleFlagBitsBD" category="bitmask">typedef <type>XrFlags64</type> <name>XrSoundObstacleFlagsBD</name>;</type> + <type bitvalues="XrSoundObjectFlagBitsBD" category="bitmask">typedef <type>XrFlags64</type> <name>XrSoundObjectFlagsBD</name>;</type> + <type bitvalues="XrSoundFieldFlagBitsBD" category="bitmask">typedef <type>XrFlags64</type> <name>XrSoundFieldFlagsBD</name>;</type> + + <!-- Bitmask types for XR_ML_facial_expression --> + <type bitvalues="XrFacialExpressionBlendShapePropertiesFlagBitsML" category="bitmask">typedef <type>XrFlags64</type> <name>XrFacialExpressionBlendShapePropertiesFlagsML</name>;</type> + + <!-- Bitmask types for XR_BD_spatial_mesh --> + <type bitvalues="XrSpatialMeshConfigFlagBitsBD" category="bitmask">typedef <type>XrFlags64</type> <name>XrSpatialMeshConfigFlagsBD</name>;</type> + + <!-- Bitmask types for XR_ANDROID_geospatial --> + <type bitvalues="XrGeospatialPoseFlagBitsANDROID" category="bitmask">typedef <type>XrFlags64</type> <name>XrGeospatialPoseFlagsANDROID</name>;</type> + + <!-- Bitmask types for XR_BD_spatial_light_estimation --> + <type bitvalues="XrLightEstimationCreateFlagBitsBD" category="bitmask">typedef <type>XrFlags64</type> <name>XrLightEstimationCreateFlagsBD</name>;</type> + + + <!-- Handles referring to internally-maintained objects. --> + <!-- These types which can be 64-bit integers or opaque pointers, selected at compile time based on pointer size --> + <type category="handle"><type>XR_DEFINE_HANDLE</type>(<name>XrInstance</name>)</type> + <type category="handle" parent="XrInstance"><type>XR_DEFINE_HANDLE</type>(<name>XrSession</name>)</type> + <type category="handle" parent="XrInstance"><type>XR_DEFINE_HANDLE</type>(<name>XrActionSet</name>)</type> + <type category="handle" parent="XrActionSet"><type>XR_DEFINE_HANDLE</type>(<name>XrAction</name>)</type> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSwapchain</name>)</type> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSpace</name>)</type> + + <!-- XR_EXT_debug_utils --> + <type category="handle" parent="XrInstance"><type>XR_DEFINE_HANDLE</type>(<name>XrDebugUtilsMessengerEXT</name>)</type> + + <!-- XR_MSFT_spatial_anchor --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSpatialAnchorMSFT</name>)</type> + + <!-- XR_EXT_hand_tracking --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrHandTrackerEXT</name>)</type> + + <!-- XR_FB_foveation --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrFoveationProfileFB</name>)</type> + + <!-- XR_FB_triangle_mesh --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrTriangleMeshFB</name>)</type> + + <!-- XR_FB_passthrough --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrPassthroughFB</name>)</type> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrPassthroughLayerFB</name>)</type> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrGeometryInstanceFB</name>)</type> + + <!-- XR_HTC_facial_tracking --> + <type category="handle" parent="XrInstance"><type>XR_DEFINE_HANDLE</type>(<name>XrFacialTrackerHTC</name>)</type> + + <!-- XR_HTC_passthrough --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrPassthroughHTC</name>)</type> + + <!-- XR_ANDROID_face_tracking --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrFaceTrackerANDROID</name>)</type> + + <!-- XR_ANDROID_trackables_marker --> + <type name="XrTrackableMarkerTrackingModeANDROID" category="enum"/> + <type name="XrTrackableMarkerDictionaryANDROID" category="enum"/> + + <!-- XR_ANDROID_device_anchor_persistence --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrDeviceAnchorPersistenceANDROID</name>)</type> + + <!-- XR_ANDROID_composition_layer_passthrough_mesh --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrPassthroughLayerANDROID</name>)</type> + + <!-- XR_ANDROID_scene_meshing --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSceneMeshingTrackerANDROID</name>)</type> + <type category="handle" parent="XrSceneMeshingTrackerANDROID"><type>XR_DEFINE_HANDLE</type>(<name>XrSceneMeshSnapshotANDROID</name>)</type> + + <!-- XR_ANDROID_eye_tracking --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrEyeTrackerANDROID</name>)</type> + + <!-- XR_ANDROID_light_estimation --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrLightEstimatorANDROID</name>)</type> + + <!-- XR_FB_face_tracking --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrFaceTrackerFB</name>)</type> + + <!-- XR_FB_face_tracking2 --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrFaceTracker2FB</name>)</type> + + <!-- XR_FB_body_tracking --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrBodyTrackerFB</name>)</type> + + <!-- XR_FB_eye_tracking_social --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrEyeTrackerFB</name>)</type> + + <!-- XR_FB_spatial_entity_user --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSpaceUserFB</name>)</type> + + <!-- XR_META_passthrough_color_lut --> + <type category="handle" parent="XrPassthroughFB"><type>XR_DEFINE_HANDLE</type>(<name>XrPassthroughColorLutMETA</name>)</type> + + <!-- XR_EXT_plane_detection --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrPlaneDetectorEXT</name>)</type> + + <!-- XR_META_virtual_keyboard --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrVirtualKeyboardMETA</name>)</type> + + <!-- XR_ML_spatial_anchors_storage --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSpatialAnchorsStorageML</name>)</type> + + <!-- XR_ML_localization_map --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrExportedLocalizationMapML</name>)</type> + + <!-- XR_ML_marker_understanding --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrMarkerDetectorML</name>)</type> + + <!-- XR_ML_facial_expression --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrFacialExpressionClientML</name>)</type> + + <!-- XR_META_environment_depth --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrEnvironmentDepthProviderMETA</name>)</type> + <type category="handle" parent="XrEnvironmentDepthProviderMETA"><type>XR_DEFINE_HANDLE</type>(<name>XrEnvironmentDepthSwapchainMETA</name>)</type> + + <!-- XR_EXT_spatial_entity --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSpatialContextEXT</name>)</type> + <type category="handle" parent="XrSpatialContextEXT"><type>XR_DEFINE_HANDLE</type>(<name>XrSpatialEntityEXT</name>)</type> + <type category="handle" parent="XrSpatialContextEXT"><type>XR_DEFINE_HANDLE</type>(<name>XrSpatialSnapshotEXT</name>)</type> + + <!-- XR_EXT_spatial_persistence --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSpatialPersistenceContextEXT</name>)</type> + + <!-- XR_HTC_body_tracking --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrBodyTrackerHTC</name>)</type> + + <!-- XR_ML_world_mesh_detection --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrWorldMeshDetectorML</name>)</type> + + <!-- XR_BD_spatial_audio_rendering --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSpatialAudioRendererBD</name>)</type> + <type category="handle" parent="XrSpatialAudioRendererBD"><type>XR_DEFINE_HANDLE</type>(<name>XrSoundFieldBD</name>)</type> + <type category="handle" parent="XrSpatialAudioRendererBD"><type>XR_DEFINE_HANDLE</type>(<name>XrSoundObjectBD</name>)</type> + <type category="handle" parent="XrSpatialAudioRendererBD"><type>XR_DEFINE_HANDLE</type>(<name>XrSoundObstacleBD</name>)</type> + <type category="handle" parent="XrSpatialAudioRendererBD"><type>XR_DEFINE_HANDLE</type>(<name>XrSoundObstacleMaterialBD</name>)</type> + + <!-- XR_BD_body_tracking --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrBodyTrackerBD</name>)</type> + + <!-- XR_EXT_render_model --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrRenderModelEXT</name>)</type> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrRenderModelAssetEXT</name>)</type> + + <!-- XR_BD_spatial_sensing --> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrSpatialEntityIdBD</name>)</type> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSenseDataProviderBD</name>)</type> + <type category="handle" parent="XrSenseDataProviderBD"><type>XR_DEFINE_HANDLE</type>(<name>XrSenseDataSnapshotBD</name>)</type> + <type category="handle" parent="XrSenseDataProviderBD"><type>XR_DEFINE_HANDLE</type>(<name>XrAnchorBD</name>)</type> + + <!-- XR_BD_facial_simulation --> + <type category="handle" parent="XrSession"> <type>XR_DEFINE_HANDLE</type>(<name>XrFaceTrackerBD</name>)</type> + + <!-- XR_META_environment_raycast --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrEnvironmentRaycasterMETA</name>)</type> + + <!-- XR_ANDROID_geospatial --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrGeospatialTrackerANDROID</name>)</type> + + <!-- XR_BD_camera_image --> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrCameraIdBD</name>)</type> + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrCameraImageIdBD</name>)</type> + <type category="handle" parent="XrInstance"><type>XR_DEFINE_HANDLE</type>(<name>XrCameraDeviceBD</name>)</type> + <type category="handle" parent="XrCameraDeviceBD"><type>XR_DEFINE_HANDLE</type>(<name>XrCameraCaptureSessionBD</name>)</type> + + + <!-- Non-handle 64-bit opaque type from XR_EXT_future --> + <type category="basetype"><type>XR_DEFINE_OPAQUE_64</type>(<name>XrFutureEXT</name>)</type> + + + <!-- enums and flag bits generated from corresponding <enums> tags below --> + <type name="XrLoaderInterfaceStructs" category="enum"/> + <type name="XrStructureType" category="enum"/> + <type name="XrResult" category="enum"/> + <type name="XrObjectType" category="enum"/> + <type name="XrInstanceCreateFlagBits" category="enum"/> + <type name="XrSessionCreateFlagBits" category="enum"/> + <type name="XrSwapchainCreateFlagBits" category="enum"/> + <type name="XrSwapchainUsageFlagBits" category="enum"/> + <type name="XrViewStateFlagBits" category="enum"/> + <type name="XrCompositionLayerFlagBits" category="enum"/> + <type name="XrSpaceLocationFlagBits" category="enum"/> + <type name="XrSpaceVelocityFlagBits" category="enum"/> + <type name="XrInputSourceLocalizedNameFlagBits" category="enum"/> + <type name="XrAndroidThreadTypeKHR" category="enum"/> + <type name="XrEyeVisibility" category="enum"/> + <type name="XrActionType" category="enum"/> + <type name="XrReferenceSpaceType" category="enum"/> + <type name="XrFormFactor" category="enum"/> + <type name="XrViewConfigurationType" category="enum"/> + <type name="XrEnvironmentBlendMode" category="enum"/> + <type name="XrSessionState" category="enum"/> + <type name="XrPerfSettingsDomainEXT" category="enum"/> + <type name="XrPerfSettingsSubDomainEXT" category="enum"/> + <type name="XrPerfSettingsLevelEXT" category="enum"/> + <type name="XrPerfSettingsNotificationLevelEXT" category="enum"/> + + <!-- flag bits for XR_KHR_vulkan_enable2 --> + <type name="XrVulkanInstanceCreateFlagBitsKHR" category="enum"/> + <type name="XrVulkanDeviceCreateFlagBitsKHR" category="enum"/> + + <!-- flag bits for XR_EXT_debug_utils --> + <type name="XrDebugUtilsMessageSeverityFlagBitsEXT" category="enum"/> + <type name="XrDebugUtilsMessageTypeFlagBitsEXT" category="enum"/> + + <!-- flag bits for XR_EXT_frame_synthesis --> + <type name="XrFrameSynthesisInfoFlagBitsEXT" category="enum"/> + + <!-- flag bits for XR_EXTX_overlay --> + <type name="XrOverlayMainSessionFlagBitsEXTX" category="enum"/> + <type name="XrOverlaySessionCreateFlagBitsEXTX" category="enum"/> + + <!-- enums for XR_KHR_visibility_mask --> + <type name="XrVisibilityMaskTypeKHR" category="enum"/> + + <!-- enums for XR_MSFT_spatial_graph_bridge --> + <type name="XrSpatialGraphNodeTypeMSFT" category="enum"/> + + <!-- flag bits for XR_FB_android_surface_swapchain_create --> + <type name="XrAndroidSurfaceSwapchainFlagBitsFB" category="enum"/> + + <!-- flag bits for XR_FB_composition_layer_image_layout --> + <type name="XrCompositionLayerImageLayoutFlagBitsFB" category="enum"/> + + <!-- enums for XR_FB_composition_layer_alpha_blend --> + <type name="XrBlendFactorFB" category="enum"/> + + <!-- flag bits for XR_FB_composition_layer_secure_content --> + <type name="XrCompositionLayerSecureContentFlagBitsFB" category="enum"/> + + <!-- enums for XR_FB_spatial_entity --> + <type name="XrSpaceComponentTypeFB" category="enum"/> + + <!-- flag bits for XR_FB_foveation --> + <type name="XrSwapchainCreateFoveationFlagBitsFB" category="enum"/> + <type name="XrSwapchainStateFoveationFlagBitsFB" category="enum"/> + + <!-- flag bits for XR_META_foveation_eye_tracked --> + <type name="XrFoveationEyeTrackedProfileCreateFlagBitsMETA" category="enum"/> + <type name="XrFoveationEyeTrackedStateFlagBitsMETA" category="enum"/> + + <!-- enums and flag bits for XR_FB_triangle_mesh --> + <type name="XrTriangleMeshFlagBitsFB" category="enum"/> + <type name="XrWindingOrderFB" category="enum"/> + + <!-- enums and flag bits for XR_FB_passthrough --> + <type name="XrPassthroughFlagBitsFB" category="enum"/> + <type name="XrPassthroughLayerPurposeFB" category="enum"/> + <type name="XrPassthroughStateChangedFlagBitsFB" category="enum"/> + <type name="XrPassthroughCapabilityFlagBitsFB" category="enum"/> + + <!-- flag bits for XR_FB_space_warp --> + <type name="XrCompositionLayerSpaceWarpInfoFlagBitsFB" category="enum"/> + + <!-- flag bits for XR_FB_render_model --> + <type name="XrRenderModelFlagBitsFB" category="enum"/> + + <!-- enums for XR_FB_spatial_entity_query --> + <type name="XrSpaceQueryActionFB" category="enum"/> + + <!-- enums for XR_FB_spatial_entity_storage --> + <type name="XrSpaceStorageLocationFB" category="enum"/> + <type name="XrSpacePersistenceModeFB" category="enum"/> + + <!-- enums for XR_META_spatial_entity_semantic_label --> + <type name="XrSemanticLabelMETA" category="enum"/> + + <!-- enums for XR_META_boundary_visibility --> + <type name="XrBoundaryVisibilityMETA" category="enum"/> + + <!-- flag bits for XR_FB_scene --> + <type name="XrSemanticLabelsSupportFlagBitsFB" category="enum"/> + + <!-- flag bits for XR_FB_hand_tracking_aim --> + <type name="XrHandTrackingAimFlagBitsFB" category="enum"/> + + <!-- flag bits for XR_BD_body_tracking_auxiliary_metrics --> + <type name="XrSpaceAccelerationFlagBitsBD" category="enum"/> + + <!-- flag bits for XR_FB_keyboard_tracking --> + <type name="XrKeyboardTrackingFlagBitsFB" category="enum"/> + <type name="XrKeyboardTrackingQueryFlagBitsFB" category="enum"/> + + <!-- flag bits for XR_ALMALENCE_digital_lens_control --> + <type name="XrDigitalLensControlFlagBitsALMALENCE" category="enum"/> + + <!-- flag bits for XR_FB_composition_layer_settings --> + <type name="XrCompositionLayerSettingsFlagBitsFB" category="enum"/> + + <!-- enum and flag bits for XR_OCULUS_external_camera --> + <type name="XrExternalCameraStatusFlagBitsOCULUS" category="enum"/> + <type name="XrExternalCameraAttachedToDeviceOCULUS" category="enum"/> + + <!-- enums for XR_META_passthrough_color_lut --> + <type name="XrPassthroughColorLutChannelsMETA" category="enum"/> + + <!-- enum and flag bits for XR_META_performance_metrics --> + <type name="XrPerformanceMetricsCounterFlagBitsMETA" category="enum"/> + <type name="XrPerformanceMetricsCounterUnitMETA" category="enum"/> + + <!-- enum and flag bits for XR_META_passthrough_preferences --> + <type name="XrPassthroughPreferenceFlagBitsMETA" category="enum"/> + + <!-- XR_HTC_facial_tracking --> + <type name="XrFacialTrackingTypeHTC" category="enum"/> + <type name="XrEyeExpressionHTC" category="enum"/> + <type name="XrLipExpressionHTC" category="enum"/> + + <!-- enum for XR_HTC_passthrough --> + <type name="XrPassthroughFormHTC" category="enum"/> + + <!-- enums for XR_HTC_foveation --> + <type name="XrFoveationModeHTC" category="enum"/> + <type name="XrFoveationDynamicFlagBitsHTC" category="enum"/> + <type name="XrFoveationLevelHTC" category="enum"/> + + <!-- enums for XR_ANDROID_face_tracking --> + <type name="XrFaceParameterIndicesANDROID" category="enum"/> + <type name="XrFaceTrackingStateANDROID" category="enum"/> + <type name="XrFaceConfidenceRegionsANDROID" category="enum"/> + + <!-- XR_ANDROID_trackables_object --> + <type name="XrObjectLabelANDROID" category="enum"/> + + <!-- XR_ANDROID_device_anchor_persistence --> + <type name="XrAnchorPersistStateANDROID" category="enum"/> + + <!-- enum and flag bits for XR_ANDROID_performance_metrics --> + <type name="XrPerformanceMetricsCounterUnitANDROID" category="enum"/> + <type name="XrPerformanceMetricsCounterFlagBitsANDROID" category="enum"/> + + <!-- XR_ANDROID_trackables_qr_code --> + <type name="XrQrCodeTrackingModeANDROID" category="enum"/> + + <!-- XR_ANDROID_composition_layer_passthrough_mesh --> + <type name="XrWindingOrderANDROID" category="enum"/> + + <!-- XR_ANDROID_scene_meshing --> + <type name="XrSceneMeshSemanticLabelSetANDROID" category="enum"/> + <type name="XrSceneMeshSemanticLabelANDROID" category="enum"/> + <type name="XrSceneMeshTrackingStateANDROID" category="enum"/> + + <!-- enums for XR_ANDROID_eye_tracking --> + <type name="XrEyeIndexANDROID" category="enum"/> + <type name="XrEyeStateANDROID" category="enum"/> + <type name="XrEyeTrackingModeANDROID" category="enum"/> + + <!-- XR_ANDROID_light_estimation --> + <type name="XrSphericalHarmonicsKindANDROID" category="enum"/> + <type name="XrLightEstimateStateANDROID" category="enum"/> + + <!-- XR_META_local_dimming --> + <type name="XrLocalDimmingModeMETA" category="enum"/> + + <!-- enums for XR_FB_face_tracking --> + <type name="XrFaceExpressionFB" category="enum"/> + <type name="XrFaceExpressionSetFB" category="enum"/> + <type name="XrFaceConfidenceFB" category="enum"/> + + <!-- enums for XR_FB_face_tracking2 --> + <type name="XrFaceExpression2FB" category="enum"/> + <type name="XrFaceExpressionSet2FB" category="enum"/> + <type name="XrFaceTrackingDataSource2FB" category="enum"/> + <type name="XrFaceConfidence2FB" category="enum"/> + + <!-- enums for XR_META_face_tracking_visemes --> + <type name="XrFaceTrackingVisemeMETA" category="enum"/> + + <!-- enums for XR_FB_body_tracking --> + <type name="XrBodyJointFB" category="enum"/> + <type name="XrBodyJointSetFB" category="enum"/> + + <!-- enums for XR_META_body_tracking_full_body --> + <type name="XrFullBodyJointMETA" category="enum"/> + + <!-- enums for XR_META_body_tracking_calibration --> + <type name="XrBodyTrackingCalibrationStateMETA" category="enum"/> + + <!-- enums for XR_META_body_tracking_fidelity --> + <type name="XrBodyTrackingFidelityMETA" category="enum" comment="Fidelity options for body tracking expression. The application can: request a desired fidelity, and the runtime will attempt to use that fidelity to provide body tracking for this application."/> + + <!-- enum for XR_ML_frame_end_info --> + <type name="XrFrameEndInfoFlagBitsML" category="enum"/> + + <!-- enums for XR_FB_eye_tracking_social --> + <type name="XrEyePositionFB" category="enum"/> + + <!-- enums for XR_ML_global_dimmer --> + <type name="XrGlobalDimmerFrameEndInfoFlagBitsML" category="enum"/> + + <!-- enums for XR_QCOM_tracking_optimization_settings --> + <type name="XrTrackingOptimizationSettingsDomainQCOM" category="enum"/> + <type name="XrTrackingOptimizationSettingsHintQCOM" category="enum"/> + + <!-- XR_MNDX_force_feedback_curl --> + <type name="XrForceFeedbackCurlLocationMNDX" category="enum"/> + + <!-- enums for XR_EXT_plane_detection --> + <type name="XrPlaneDetectionStateEXT" category="enum"/> + <type name="XrPlaneDetectorOrientationEXT" category="enum"/> + <type name="XrPlaneDetectorSemanticTypeEXT" category="enum"/> + <type name="XrPlaneDetectorFlagBitsEXT" category="enum"/> + <type name="XrPlaneDetectionCapabilityFlagBitsEXT" category="enum"/> + + <!-- enums for XR_META_virtual_keyboard --> + <type name="XrVirtualKeyboardLocationTypeMETA" category="enum"/> + <type name="XrVirtualKeyboardInputSourceMETA" category="enum"/> + <type name="XrVirtualKeyboardInputStateFlagBitsMETA" category="enum"/> + + <!-- enums for XR_ML_user_calibration --> + <type name="XrHeadsetFitStatusML" category="enum"/> + <type name="XrEyeCalibrationStatusML" category="enum"/> + + <!-- XR_ML_localization_map --> + <type name="XrLocalizationMapStateML" category="enum"/> + <type name="XrLocalizationMapTypeML" category="enum"/> + <type name="XrLocalizationMapConfidenceML" category="enum"/> + <type name="XrLocalizationMapErrorFlagBitsML" category="enum"/> + + <!-- XR_ML_marker_understanding --> + <type name="XrMarkerDetectorProfileML" category="enum"/> + <type name="XrMarkerTypeML" category="enum"/> + <type name="XrMarkerArucoDictML" category="enum"/> + <type name="XrMarkerAprilTagDictML" category="enum"/> + <type name="XrMarkerDetectorFpsML" category="enum"/> + <type name="XrMarkerDetectorResolutionML" category="enum"/> + <type name="XrMarkerDetectorCameraML" category="enum"/> + <type name="XrMarkerDetectorCornerRefineMethodML" category="enum"/> + <type name="XrMarkerDetectorFullAnalysisIntervalML" category="enum"/> + <type name="XrMarkerDetectorStatusML" category="enum"/> + + <!-- enums for XR_ML_facial_expression --> + <type name="XrFacialBlendShapeML" category="enum"/> + <type name="XrFacialExpressionBlendShapePropertiesFlagBitsML" category="enum"/> + + <!-- XR_EXT_future --> + <type name="XrFutureStateEXT" category="enum"/> + + <!-- XR_META_environment_depth --> + <type name="XrEnvironmentDepthProviderCreateFlagBitsMETA" category="enum"/> + <type name="XrEnvironmentDepthSwapchainCreateFlagBitsMETA" category="enum"/> + + <!-- XR_EXT_spatial_entity --> + <type name="XrSpatialCapabilityEXT" category="enum"/> + <type name="XrSpatialCapabilityFeatureEXT" category="enum"/> + <type name="XrSpatialComponentTypeEXT" category="enum"/> + <type name="XrSpatialEntityTrackingStateEXT" category="enum"/> + <type name="XrSpatialBufferTypeEXT" category="enum"/> + + <!-- enums for XR_EXT_spatial_persistence --> + <type name="XrSpatialPersistenceScopeEXT" category="enum"/> + <type name="XrSpatialPersistenceContextResultEXT" category="enum"/> + <type name="XrSpatialPersistenceStateEXT" category="enum"/> + + <!-- enums for XR_EXT_spatial_plane_tracking --> + <type name="XrSpatialPlaneAlignmentEXT" category="enum"/> + <type name="XrSpatialPlaneSemanticLabelEXT" category="enum"/> + + <!-- XR_HTC_body_tracking --> + <type name="XrBodyJointHTC" category="enum"/> + <type name="XrBodyJointSetHTC" category="enum"/> + <type name="XrBodyJointConfidenceHTC" category="enum"/> + + <!-- XR_ML_spatial_anchors --> + <type name="XrSpatialAnchorConfidenceML" category="enum"/> + + <!-- XR_ML_world_mesh_detection --> + <type name="XrWorldMeshBlockStatusML" category="enum"/> + <type name="XrWorldMeshDetectorFlagBitsML" category="enum"/> + <type name="XrWorldMeshDetectorLodML" category="enum"/> + <type name="XrWorldMeshBlockResultML" category="enum"/> + + <!-- XR_BD_body_tracking --> + <type name="XrBodyJointBD" category="enum"/> + <type name="XrBodyJointSetBD" category="enum"/> + + <!-- XR_BD_spatial_audio_rendering --> + <type name="XrAudioSampleRateBD" category="enum"/> + <type name="XrAudioBufferChannelLayoutBD" category="enum"/> + <type name="XrSoundObstacleMaterialTypeBD" category="enum"/> + <type name="XrSoundObstacleFlagBitsBD" category="enum"/> + <type name="XrSoundObjectDistanceAttenuationTypeBD" category="enum"/> + <type name="XrSoundObjectFlagBitsBD" category="enum"/> + <type name="XrSoundFieldChannelMaskSurroundBD" category="enum"/> + <type name="XrSoundFieldChannelMaskAmbixBD" category="enum"/> + <type name="XrSoundFieldChannelMaskFumaBD" category="enum"/> + <type name="XrSoundFieldFlagBitsBD" category="enum"/> + + <!-- enums for XR_BD_spatial_sensing --> + <type name="XrSenseDataProviderTypeBD" category="enum"/> + <type name="XrSemanticLabelBD" category="enum"/> + <type name="XrSpatialEntityComponentTypeBD" category="enum"/> + <type name="XrSenseDataProviderStateBD" category="enum"/> + + <!-- enums for XR_BD_spatial_anchor --> + <type name="XrPersistenceLocationBD" category="enum"/> + + <!-- enums for XR_BD_spatial_mesh --> + <type name="XrSpatialMeshLodBD" category="enum"/> + <type name="XrSpatialMeshConfigFlagBitsBD" category="enum"/> + + <!-- enums for XR_BD_spatial_plane --> + <type name="XrPlaneOrientationBD" category="enum"/> + + <!-- enums for XR_BD_spatial_light_estimation --> + <type name="XrEnvironmentTextureResolutionBD" category="enum"/> + <type name="XrEnvironmentTextureTransferTypeBD" category="enum"/> + <type name="XrEnvironmentTexturePixelFormatBD" category="enum"/> + <type name="XrSphericalHarmonicsKindBD" category="enum"/> + <type name="XrLightEstimationCreateFlagBitsBD" category="enum"/> + + <!-- enums for XR_BD_dynamic_object_tracking --> + <type name="XrDynamicObjectTypeBD" category="enum"/> + + <!-- enums for XR_EXT_spatial_marker_tracking --> + <type name="XrSpatialMarkerArucoDictEXT" category="enum"/> + <type name="XrSpatialMarkerAprilTagDictEXT" category="enum"/> + + <!-- XR_BD_facial_simulation --> + <type name="XrFacialSimulationModeBD" category="enum"/> + <type name="XrFaceExpressionBD" category="enum"/> + <type name="XrLipExpressionBD" category="enum"/> + + <!-- enums for XR_ANDROID_spatial_object_tracking --> + <type name="XrSpatialObjectSemanticLabelANDROID" category="enum"/> + + <!-- XR_META_environment_raycast --> + <type name="XrEnvironmentRaycastHitStatusMETA" category="enum"/> + + <!-- XR_QCOM_hand_tracking_gesture --> + <type name="XrHandGestureTypeQCOM" category="enum"/> + + <!-- XR_EXT_haptic_parametric --> + <type name="XrHapticParametricStreamFrameTypeEXT" category="enum"/> + + <!-- XR_BD_body_tracking_auxiliary_metrics --> + <type name="XrBodyTrackingPostureBD" category="enum"/> + <type name="XrBodyTrackingStatusBD" category="enum"/> + <type name="XrBodyTrackingMessageBD" category="enum"/> + + <!-- XR_SONY_swapchain_color_space --> + <type name="XrColorSpaceSONY" category="enum"/> + + <!-- enums for XR_BD_camera_image --> + <type name="XrCameraPropertyTypeBD" category="enum"/> + <type name="XrCameraFacingBD" category="enum"/> + <type name="XrCameraPositionBD" category="enum"/> + <type name="XrCameraTypeBD" category="enum"/> + <type name="XrCameraCapabilityTypeBD" category="enum"/> + <type name="XrCameraDataTransferTypeBD" category="enum"/> + <type name="XrCameraImageFormatBD" category="enum"/> + <type name="XrCameraModelBD" category="enum"/> + + <!-- Struct types --> + <type category="struct" name="XrVector2f"> + <member><type>float</type> <name>x</name></member> + <member><type>float</type> <name>y</name></member> + </type> + <type category="struct" name="XrVector3f"> + <member><type>float</type> <name>x</name></member> + <member><type>float</type> <name>y</name></member> + <member><type>float</type> <name>z</name></member> + </type> + <type category="struct" name="XrVector4f"> + <member><type>float</type> <name>x</name></member> + <member><type>float</type> <name>y</name></member> + <member><type>float</type> <name>z</name></member> + <member><type>float</type> <name>w</name></member> + </type> + <type category="struct" name="XrColor4f"> + <member><type>float</type> <name>r</name></member> + <member><type>float</type> <name>g</name></member> + <member><type>float</type> <name>b</name></member> + <member><type>float</type> <name>a</name></member> + </type> + <type category="struct" name="XrQuaternionf"> + <member><type>float</type> <name>x</name></member> + <member><type>float</type> <name>y</name></member> + <member><type>float</type> <name>z</name></member> + <member><type>float</type> <name>w</name></member> + </type> + <type category="struct" name="XrPosef"> + <member><type>XrQuaternionf</type> <name>orientation</name></member> + <member><type>XrVector3f</type> <name>position</name></member> + </type> + <type category="struct" name="XrOffset2Df"> + <member><type>float</type> <name>x</name></member> + <member><type>float</type> <name>y</name></member> + </type> + <type category="struct" name="XrExtent2Df"> + <member><type>float</type> <name>width</name></member> + <member><type>float</type> <name>height</name></member> + </type> + + <type category="struct" name="XrExtent3DfEXT" alias="XrExtent3Df"/> + + <type category="struct" name="XrRect2Df"> + <member><type>XrOffset2Df</type> <name>offset</name></member> + <member><type>XrExtent2Df</type> <name>extent</name></member> + </type> + <type category="struct" name="XrOffset2Di"> + <member><type>int32_t</type> <name>x</name></member> + <member><type>int32_t</type> <name>y</name></member> + </type> + <type category="struct" name="XrExtent2Di"> + <member><type>int32_t</type> <name>width</name></member> + <member><type>int32_t</type> <name>height</name></member> + </type> + <type category="struct" name="XrRect2Di"> + <member><type>XrOffset2Di</type> <name>offset</name></member> + <member><type>XrExtent2Di</type> <name>extent</name></member> + </type> + + <!-- openxr_loader_negotiation.h --> + <type category="struct" name="XrNegotiateLoaderInfo"> + <member><type>XrLoaderInterfaceStructs</type> <name>structType</name></member> + <member><type>uint32_t</type> <name>structVersion</name></member> + <member><type>size_t</type> <name>structSize</name></member> + <member><type>uint32_t</type> <name>minInterfaceVersion</name></member> + <member><type>uint32_t</type> <name>maxInterfaceVersion</name></member> + <member><type>XrVersion</type> <name>minApiVersion</name></member> + <member><type>XrVersion</type> <name>maxApiVersion</name></member> + </type> + <type category="struct" name="XrNegotiateApiLayerRequest"> + <member><type>XrLoaderInterfaceStructs</type> <name>structType</name></member> + <member><type>uint32_t</type> <name>structVersion</name></member> + <member><type>size_t</type> <name>structSize</name></member> + <member><type>uint32_t</type> <name>layerInterfaceVersion</name></member> + <member><type>XrVersion</type> <name>layerApiVersion</name></member> + <member><type>PFN_xrGetInstanceProcAddr</type> <name>getInstanceProcAddr</name></member> + <member><type>PFN_xrCreateApiLayerInstance</type> <name>createApiLayerInstance</name></member> + </type> + <type category="struct" name="XrNegotiateRuntimeRequest"> + <member><type>XrLoaderInterfaceStructs</type> <name>structType</name></member> + <member><type>uint32_t</type> <name>structVersion</name></member> + <member><type>size_t</type> <name>structSize</name></member> + <member><type>uint32_t</type> <name>runtimeInterfaceVersion</name></member> + <member><type>XrVersion</type> <name>runtimeApiVersion</name></member> + <member><type>PFN_xrGetInstanceProcAddr</type> <name>getInstanceProcAddr</name></member> + </type> + + <type category="struct" name="XrApiLayerNextInfo"> + <member><type>XrLoaderInterfaceStructs</type> <name>structType</name></member> + <member><type>uint32_t</type> <name>structVersion</name></member> + <member><type>size_t</type> <name>structSize</name></member> + <member><type>char</type> <name>layerName</name>[<enum>XR_MAX_API_LAYER_NAME_SIZE</enum>]</member> + <member><type>PFN_xrGetInstanceProcAddr</type> <name>nextGetInstanceProcAddr</name></member> + <member><type>PFN_xrCreateApiLayerInstance</type> <name>nextCreateApiLayerInstance</name></member> + <member>struct <type>XrApiLayerNextInfo</type>* <name>next</name></member> + </type> + <type category="struct" name="XrApiLayerCreateInfo"> + <member><type>XrLoaderInterfaceStructs</type> <name>structType</name></member> + <member><type>uint32_t</type> <name>structVersion</name></member> + <member><type>size_t</type> <name>structSize</name></member> + <member><type>void</type>* <name>loaderInstance</name></member> + <member><type>char</type> <name>settings_file_location</name>[XR_API_LAYER_MAX_SETTINGS_PATH_SIZE]</member> + <member><type>XrApiLayerNextInfo</type>* <name>nextInfo</name></member> + </type> + + <comment> + XrBaseInStructure and XrBaseOutStructure use "struct" in their member definitions + because they are recursive structures and this is easier than modifying the tooling + to output forward declarations. + </comment> + <type category="struct" name="XrBaseInStructure" mayalias="true"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const struct <type>XrBaseInStructure</type>* <name>next</name></member> + </type> + <type category="struct" name="XrBaseOutStructure" mayalias="true"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>struct <type>XrBaseOutStructure</type>* <name>next</name></member> + </type> + <type category="struct" name="XrApiLayerProperties" returnedonly="true"> + <member values="XR_TYPE_API_LAYER_PROPERTIES"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>char</type> <name>layerName</name>[<enum>XR_MAX_API_LAYER_NAME_SIZE</enum>]</member> + <member><type>XrVersion</type> <name>specVersion</name></member> + <member><type>uint32_t</type> <name>layerVersion</name></member> + <member><type>char</type> <name>description</name>[<enum>XR_MAX_API_LAYER_DESCRIPTION_SIZE</enum>]</member> + </type> + <type category="struct" name="XrExtensionProperties" returnedonly="true"> + <member values="XR_TYPE_EXTENSION_PROPERTIES"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>char</type> <name>extensionName</name>[<enum>XR_MAX_EXTENSION_NAME_SIZE</enum>]</member> + <member><type>uint32_t</type> <name>extensionVersion</name></member> + </type> + <type category="struct" name="XrApplicationInfo"> + <member><type>char</type> <name>applicationName</name>[<enum>XR_MAX_APPLICATION_NAME_SIZE</enum>]</member> + <member><type>uint32_t</type> <name>applicationVersion</name></member> + <member><type>char</type> <name>engineName</name>[<enum>XR_MAX_ENGINE_NAME_SIZE</enum>]</member> + <member><type>uint32_t</type> <name>engineVersion</name></member> + <member><type>XrVersion</type> <name>apiVersion</name></member> + </type> + <type category="struct" name="XrInstanceCreateInfo"> + <member values="XR_TYPE_INSTANCE_CREATE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrInstanceCreateFlags</type> <name>createFlags</name></member> + <member><type>XrApplicationInfo</type> <name>applicationInfo</name></member> + <member optional="true"><type>uint32_t</type> <name>enabledApiLayerCount</name></member> + <member len="enabledApiLayerCount,null-terminated">const <type>char</type>* const* <name>enabledApiLayerNames</name></member> + <member optional="true"><type>uint32_t</type> <name>enabledExtensionCount</name></member> + <member len="enabledExtensionCount,null-terminated">const <type>char</type>* const* <name>enabledExtensionNames</name></member> + </type> + <type category="struct" name="XrInstanceProperties" returnedonly="true"> + <member values="XR_TYPE_INSTANCE_PROPERTIES"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrVersion</type> <name>runtimeVersion</name></member> + <member><type>char</type> <name>runtimeName</name>[<enum>XR_MAX_RUNTIME_NAME_SIZE</enum>]</member> + </type> + <type category="struct" name="XrSystemGetInfo"> + <member values="XR_TYPE_SYSTEM_GET_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrFormFactor</type> <name>formFactor</name></member> + </type> + <type category="struct" name="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_PROPERTIES"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrSystemId</type> <name>systemId</name></member> + <member><type>uint32_t</type> <name>vendorId</name></member> + <member><type>char</type> <name>systemName</name>[<enum>XR_MAX_SYSTEM_NAME_SIZE</enum>]</member> + <member><type>XrSystemGraphicsProperties</type> <name>graphicsProperties</name></member> + <member><type>XrSystemTrackingProperties</type> <name>trackingProperties</name></member> + </type> + <type category="struct" name="XrSystemGraphicsProperties"> + <member><type>uint32_t</type> <name>maxSwapchainImageHeight</name></member> + <member><type>uint32_t</type> <name>maxSwapchainImageWidth</name></member> + <member><type>uint32_t</type> <name>maxLayerCount</name></member> + </type> + <type category="struct" name="XrSystemTrackingProperties"> + <member><type>XrBool32</type> <name>orientationTracking</name></member> + <member><type>XrBool32</type> <name>positionTracking</name></member> + </type> + <type category="struct" name="XrGraphicsBindingOpenGLWin32KHR" structextends="XrSessionCreateInfo" protect="XR_USE_PLATFORM_WIN32"> + <member values="XR_TYPE_GRAPHICS_BINDING_OPENGL_WIN32_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>HDC</type> <name>hDC</name></member> + <member><type>HGLRC</type> <name>hGLRC</name></member> + </type> + <type category="struct" name="XrGraphicsBindingOpenGLXlibKHR" structextends="XrSessionCreateInfo" protect="XR_USE_PLATFORM_XLIB"> + <member values="XR_TYPE_GRAPHICS_BINDING_OPENGL_XLIB_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>Display</type>* <name>xDisplay</name></member> + <member><type>uint32_t</type> <name>visualid</name></member> + <member><type>GLXFBConfig</type> <name>glxFBConfig</name></member> + <member><type>GLXDrawable</type> <name>glxDrawable</name></member> + <member><type>GLXContext</type> <name>glxContext</name></member> + </type> + <type category="struct" name="XrGraphicsBindingOpenGLXcbKHR" structextends="XrSessionCreateInfo" protect="XR_USE_PLATFORM_XCB"> + <member values="XR_TYPE_GRAPHICS_BINDING_OPENGL_XCB_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>xcb_connection_t</type>* <name>connection</name></member> + <member><type>uint32_t</type> <name>screenNumber</name></member> + <member><type>xcb_glx_fbconfig_t</type> <name>fbconfigid</name></member> + <member><type>xcb_visualid_t</type> <name>visualid</name></member> + <member><type>xcb_glx_drawable_t</type> <name>glxDrawable</name></member> + <member><type>xcb_glx_context_t</type> <name>glxContext</name></member> + </type> + <!-- Deprecated, see Wayland Notes in appendix. --> + <type category="struct" name="XrGraphicsBindingOpenGLWaylandKHR" structextends="XrSessionCreateInfo" protect="XR_USE_PLATFORM_WAYLAND"> + <member values="XR_TYPE_GRAPHICS_BINDING_OPENGL_WAYLAND_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member>struct <type>wl_display</type>* <name>display</name></member> + </type> + <type category="struct" name="XrGraphicsBindingD3D11KHR" structextends="XrSessionCreateInfo"> + <member values="XR_TYPE_GRAPHICS_BINDING_D3D11_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>ID3D11Device</type>* <name>device</name></member> + </type> + <type category="struct" name="XrGraphicsBindingD3D12KHR" structextends="XrSessionCreateInfo"> + <member values="XR_TYPE_GRAPHICS_BINDING_D3D12_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>ID3D12Device</type>* <name>device</name></member> + <member><type>ID3D12CommandQueue</type>* <name>queue</name></member> + </type> + <type category="struct" name="XrGraphicsBindingOpenGLESAndroidKHR" structextends="XrSessionCreateInfo" protect="XR_USE_PLATFORM_ANDROID"> + <member values="XR_TYPE_GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>EGLDisplay</type> <name>display</name></member> + <member><type>EGLConfig</type> <name>config</name></member> + <member><type>EGLContext</type> <name>context</name></member> + </type> + <type category="struct" name="XrGraphicsBindingVulkanKHR" structextends="XrSessionCreateInfo"> + <member values="XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>VkInstance</type> <name>instance</name></member> + <member><type>VkPhysicalDevice</type> <name>physicalDevice</name></member> + <member><type>VkDevice</type> <name>device</name></member> + <member><type>uint32_t</type> <name>queueFamilyIndex</name></member> + <member><type>uint32_t</type> <name>queueIndex</name></member> + </type> + <type category="struct" name="XrGraphicsBindingMetalKHR" structextends="XrSessionCreateInfo"> + <member values="XR_TYPE_GRAPHICS_BINDING_METAL_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>void</type>* <name>commandQueue</name></member> + </type> + <type category="struct" name="XrSessionCreateInfo"> + <member values="XR_TYPE_SESSION_CREATE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrSessionCreateFlags</type> <name>createFlags</name></member> + <member><type>XrSystemId</type> <name>systemId</name></member> + </type> + <type category="struct" name="XrSessionBeginInfo"> + <member values="XR_TYPE_SESSION_BEGIN_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrViewConfigurationType</type> <name>primaryViewConfigurationType</name></member> + </type> + <type category="struct" name="XrSwapchainCreateInfo"> + <member values="XR_TYPE_SWAPCHAIN_CREATE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrSwapchainCreateFlags</type> <name>createFlags</name></member> + <member optional="true"><type>XrSwapchainUsageFlags</type> <name>usageFlags</name></member> + <member><type>int64_t</type> <name>format</name></member> + <member><type>uint32_t</type> <name>sampleCount</name></member> + <member><type>uint32_t</type> <name>width</name></member> + <member><type>uint32_t</type> <name>height</name></member> + <member><type>uint32_t</type> <name>faceCount</name></member> + <member><type>uint32_t</type> <name>arraySize</name></member> + <member><type>uint32_t</type> <name>mipCount</name></member> + </type> + <type category="struct" name="XrSwapchainImageBaseHeader" returnedonly="true"> + <member><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrSwapchainImageOpenGLKHR" parentstruct="XrSwapchainImageBaseHeader" returnedonly="true"> + <member values="XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_KHR"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>image</name></member> + </type> + <type category="struct" name="XrSwapchainImageOpenGLESKHR" parentstruct="XrSwapchainImageBaseHeader" returnedonly="true"> + <member values="XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>image</name></member> + </type> + <type category="struct" name="XrSwapchainImageVulkanKHR" parentstruct="XrSwapchainImageBaseHeader" returnedonly="true"> + <member values="XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>VkImage</type> <name>image</name></member> + </type> + <type category="struct" name="XrSwapchainImageD3D11KHR" parentstruct="XrSwapchainImageBaseHeader" returnedonly="true"> + <member values="XR_TYPE_SWAPCHAIN_IMAGE_D3D11_KHR"> <type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>ID3D11Texture2D</type>* <name>texture</name></member> + </type> + <type category="struct" name="XrSwapchainImageD3D12KHR" parentstruct="XrSwapchainImageBaseHeader" returnedonly="true"> + <member values="XR_TYPE_SWAPCHAIN_IMAGE_D3D12_KHR"> <type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>ID3D12Resource</type>* <name>texture</name></member> + </type> + <type category="struct" name="XrSwapchainImageMetalKHR" parentstruct="XrSwapchainImageBaseHeader" returnedonly="true"> + <member values="XR_TYPE_SWAPCHAIN_IMAGE_METAL_KHR"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>void</type>* <name>texture</name></member> + </type> + <type category="struct" name="XrSwapchainImageAcquireInfo"> + <member values="XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrSwapchainImageWaitInfo"> + <member values="XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrDuration</type> <name>timeout</name></member> + </type> + <type category="struct" name="XrSwapchainImageReleaseInfo"> + <member values="XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrReferenceSpaceCreateInfo"> + <member values="XR_TYPE_REFERENCE_SPACE_CREATE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrReferenceSpaceType</type> <name>referenceSpaceType</name></member> + <member><type>XrPosef</type> <name>poseInReferenceSpace</name></member> + </type> + <type category="struct" name="XrActionSpaceCreateInfo"> + <member values="XR_TYPE_ACTION_SPACE_CREATE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAction</type> <name>action</name></member> + <member optional="true"><type>XrPath</type> <name>subactionPath</name></member> + <member><type>XrPosef</type> <name>poseInActionSpace</name></member> + </type> + <type category="struct" name="XrSpaceLocation"> + <member values="XR_TYPE_SPACE_LOCATION"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrSpaceLocationFlags</type> <name>locationFlags</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrSpaceVelocity" structextends="XrSpaceLocation"> + <member values="XR_TYPE_SPACE_VELOCITY"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrSpaceVelocityFlags</type> <name>velocityFlags</name></member> + <member><type>XrVector3f</type> <name>linearVelocity</name></member> + <member><type>XrVector3f</type> <name>angularVelocity</name></member> + </type> + <type category="struct" name="XrFovf"> + <member><type>float</type> <name>angleLeft</name></member> + <member><type>float</type> <name>angleRight</name></member> + <member><type>float</type> <name>angleUp</name></member> + <member><type>float</type> <name>angleDown</name></member> + </type> + <type category="struct" name="XrView"> + <member values="XR_TYPE_VIEW"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrFovf</type> <name>fov</name></member> + </type> + <type category="struct" name="XrViewLocateInfo"> + <member values="XR_TYPE_VIEW_LOCATE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></member> + <member><type>XrTime</type> <name>displayTime</name></member> + <member><type>XrSpace</type> <name>space</name></member> + </type> + <type category="struct" name="XrViewState"> + <member values="XR_TYPE_VIEW_STATE"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrViewStateFlags</type> <name>viewStateFlags</name></member> + </type> + <type category="struct" name="XrViewConfigurationView"> + <member values="XR_TYPE_VIEW_CONFIGURATION_VIEW"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>recommendedImageRectWidth</name></member> + <member><type>uint32_t</type> <name>maxImageRectWidth</name></member> + <member><type>uint32_t</type> <name>recommendedImageRectHeight</name></member> + <member><type>uint32_t</type> <name>maxImageRectHeight</name></member> + <member><type>uint32_t</type> <name>recommendedSwapchainSampleCount</name></member> + <member><type>uint32_t</type> <name>maxSwapchainSampleCount</name></member> + </type> + <type category="struct" name="XrSwapchainSubImage"> + <member><type>XrSwapchain</type> <name>swapchain</name></member> + <member><type>XrRect2Di</type> <name>imageRect</name></member> + <member><type>uint32_t</type> <name>imageArrayIndex</name></member> + </type> + <type category="struct" name="XrCompositionLayerBaseHeader"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrCompositionLayerFlags</type> <name>layerFlags</name></member> + <member><type>XrSpace</type> <name>space</name></member> + </type> + <type category="struct" name="XrCompositionLayerProjectionView"> + <member values="XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrFovf</type> <name>fov</name></member> + <member><type>XrSwapchainSubImage</type> <name>subImage</name></member> + </type> + <type category="struct" name="XrCompositionLayerProjection" parentstruct="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_PROJECTION"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrCompositionLayerFlags</type> <name>layerFlags</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>uint32_t</type> <name>viewCount</name></member> + <member len="viewCount">const <type>XrCompositionLayerProjectionView</type>* <name>views</name></member> + </type> + <type category="struct" name="XrCompositionLayerQuad" parentstruct="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_QUAD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrCompositionLayerFlags</type> <name>layerFlags</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrEyeVisibility</type> <name>eyeVisibility</name></member> + <member><type>XrSwapchainSubImage</type> <name>subImage</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrExtent2Df</type> <name>size</name></member> + </type> + <type category="struct" name="XrCompositionLayerCylinderKHR" parentstruct="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_CYLINDER_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrCompositionLayerFlags</type> <name>layerFlags</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrEyeVisibility</type> <name>eyeVisibility</name></member> + <member><type>XrSwapchainSubImage</type> <name>subImage</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>float</type> <name>radius</name></member> + <member><type>float</type> <name>centralAngle</name></member> + <member><type>float</type> <name>aspectRatio</name></member> + </type> + <type category="struct" name="XrCompositionLayerCubeKHR" parentstruct="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_CUBE_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrCompositionLayerFlags</type> <name>layerFlags</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrEyeVisibility</type> <name>eyeVisibility</name></member> + <member><type>XrSwapchain</type> <name>swapchain</name></member> + <member><type>uint32_t</type> <name>imageArrayIndex</name></member> + <member><type>XrQuaternionf</type> <name>orientation</name></member> + </type> + <type category="struct" name="XrCompositionLayerEquirectKHR" parentstruct="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_EQUIRECT_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrCompositionLayerFlags</type> <name>layerFlags</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrEyeVisibility</type> <name>eyeVisibility</name></member> + <member><type>XrSwapchainSubImage</type> <name>subImage</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>float</type> <name>radius</name></member> + <member><type>XrVector2f</type> <name>scale</name></member> + <member><type>XrVector2f</type> <name>bias</name></member> + </type> + <type category="struct" name="XrCompositionLayerDepthInfoKHR" structextends="XrCompositionLayerProjectionView"> + <member values="XR_TYPE_COMPOSITION_LAYER_DEPTH_INFO_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSwapchainSubImage</type> <name>subImage</name></member> + <member><type>float</type> <name>minDepth</name></member> + <member><type>float</type> <name>maxDepth</name></member> + <member><type>float</type> <name>nearZ</name></member> + <member><type>float</type> <name>farZ</name></member> + </type> + <type category="struct" name="XrFrameBeginInfo"> + <member values="XR_TYPE_FRAME_BEGIN_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <!-- This is currently empty, awaiting future extensions. --> + </type> + <type category="struct" name="XrFrameEndInfo"> + <member values="XR_TYPE_FRAME_END_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>displayTime</name></member> + <member><type>XrEnvironmentBlendMode</type> <name>environmentBlendMode</name></member> + <member optional="true"><type>uint32_t</type> <name>layerCount</name></member> + <member optional="true" len="layerCount">const <type>XrCompositionLayerBaseHeader</type>* const* <name>layers</name></member> + </type> + <type category="struct" name="XrFrameWaitInfo"> + <member values="XR_TYPE_FRAME_WAIT_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrFrameState"> + <member values="XR_TYPE_FRAME_STATE"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>predictedDisplayTime</name></member> + <member><type>XrDuration</type> <name>predictedDisplayPeriod</name></member> + <member><type>XrBool32</type> <name>shouldRender</name></member> + </type> + <type category="struct" name="XrHapticBaseHeader"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrHapticVibration" parentstruct="XrHapticBaseHeader"> + <member values="XR_TYPE_HAPTIC_VIBRATION"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrDuration</type> <name>duration</name></member> + <member optional="true"><type>float</type> <name>frequency</name></member> + <member><type>float</type> <name>amplitude</name></member> + </type> + <type category="struct" name="XrEventDataBaseHeader" returnedonly="true"> <!-- top-level, parentstruct="XrBaseOutStructure" causes validation failures --> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrEventDataBuffer"> <!-- top-level, parentstruct="XrBaseInStructure" causes validation failures --> + <member values="XR_TYPE_EVENT_DATA_BUFFER"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint8_t</type> <name>varying</name>[4000]</member> + </type> + <type category="struct" name="XrEventDataEventsLost" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_EVENTS_LOST"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>lostEventCount</name></member> + </type> + <type category="struct" name="XrEventDataInstanceLossPending" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>lossTime</name></member> + </type> + <type category="struct" name="XrEventDataSessionStateChanged" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED"> <type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSession</type> <name>session</name></member> + <member><type>XrSessionState</type> <name>state</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrEventDataReferenceSpaceChangePending" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSession</type> <name>session</name></member> + <member><type>XrReferenceSpaceType</type> <name>referenceSpaceType</name></member> + <member><type>XrTime</type> <name>changeTime</name></member> + <member><type>XrBool32</type> <name>poseValid</name></member> + <member><type>XrPosef</type> <name>poseInPreviousSpace</name></member> + </type> + <type category="struct" name="XrEventDataPerfSettingsEXT" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_PERF_SETTINGS_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPerfSettingsDomainEXT</type> <name>domain</name></member> + <member><type>XrPerfSettingsSubDomainEXT</type> <name>subDomain</name></member> + <member><type>XrPerfSettingsNotificationLevelEXT</type> <name>fromLevel</name></member> + <member><type>XrPerfSettingsNotificationLevelEXT</type> <name>toLevel</name></member> + </type> + <type category="struct" name="XrEventDataVisibilityMaskChangedKHR" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSession</type> <name>session</name></member> + <member><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></member> + <member><type>uint32_t</type> <name>viewIndex</name></member> + </type> + <type category="struct" name="XrViewConfigurationProperties"> + <member values="XR_TYPE_VIEW_CONFIGURATION_PROPERTIES"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></member> + <member><type>XrBool32</type> <name>fovMutable</name></member> + </type> + <type category="struct" name="XrActionStateBoolean"> + <member values="XR_TYPE_ACTION_STATE_BOOLEAN"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>currentState</name></member> + <member><type>XrBool32</type> <name>changedSinceLastSync</name></member> + <member><type>XrTime</type> <name>lastChangeTime</name></member> + <member><type>XrBool32</type> <name>isActive</name></member> + </type> + <type category="struct" name="XrActionStateFloat"> + <member values="XR_TYPE_ACTION_STATE_FLOAT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>float</type> <name>currentState</name></member> + <member><type>XrBool32</type> <name>changedSinceLastSync</name></member> + <member><type>XrTime</type> <name>lastChangeTime</name></member> + <member><type>XrBool32</type> <name>isActive</name></member> + </type> + + <type category="struct" name="XrActionStateVector2f"> + <member values="XR_TYPE_ACTION_STATE_VECTOR2F"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrVector2f</type> <name>currentState</name></member> + <member><type>XrBool32</type> <name>changedSinceLastSync</name></member> + <member><type>XrTime</type> <name>lastChangeTime</name></member> + <member><type>XrBool32</type> <name>isActive</name></member> + </type> + + <type category="struct" name="XrActionStatePose"> + <member values="XR_TYPE_ACTION_STATE_POSE"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>isActive</name></member> + </type> + + <type category="struct" name="XrActionStateGetInfo"> + <member values="XR_TYPE_ACTION_STATE_GET_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAction</type> <name>action</name></member> + <member optional="true"><type>XrPath</type> <name>subactionPath</name></member> + </type> + + <type category="struct" name="XrHapticActionInfo"> + <member values="XR_TYPE_HAPTIC_ACTION_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAction</type> <name>action</name></member> + <member optional="true"><type>XrPath</type> <name>subactionPath</name></member> + </type> + + <type category="struct" name="XrActionSetCreateInfo"> + <member values="XR_TYPE_ACTION_SET_CREATE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>char</type> <name>actionSetName</name>[<enum>XR_MAX_ACTION_SET_NAME_SIZE</enum>]</member> + <member><type>char</type> <name>localizedActionSetName</name>[<enum>XR_MAX_LOCALIZED_ACTION_SET_NAME_SIZE</enum>]</member> + <member><type>uint32_t</type> <name>priority</name></member> + </type> + + <type category="struct" name="XrActionSuggestedBinding"> + <member><type>XrAction</type> <name>action</name></member> + <member><type>XrPath</type> <name>binding</name></member> + </type> + + <type category="struct" name="XrInteractionProfileSuggestedBinding"> + <member values="XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPath</type> <name>interactionProfile</name></member> + <member><type>uint32_t</type> <name>countSuggestedBindings</name></member> + <member len="countSuggestedBindings">const <type>XrActionSuggestedBinding</type>* <name>suggestedBindings</name></member> + </type> + + <type category="struct" name="XrActiveActionSet"> + <member><type>XrActionSet</type> <name>actionSet</name></member> + <member><type>XrPath</type> <name>subactionPath</name></member> + </type> + + <type category="struct" name="XrSessionActionSetsAttachInfo"> + <member values="XR_TYPE_SESSION_ACTION_SETS_ATTACH_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>countActionSets</name></member> + <member len="countActionSets">const <type>XrActionSet</type>* <name>actionSets</name></member> + </type> + + <type category="struct" name="XrActionsSyncInfo"> + <member values="XR_TYPE_ACTIONS_SYNC_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>countActiveActionSets</name></member> + <member optional="true" len="countActiveActionSets">const <type>XrActiveActionSet</type>* <name>activeActionSets</name></member> + </type> + + <type category="struct" name="XrBoundSourcesForActionEnumerateInfo"> + <member values="XR_TYPE_BOUND_SOURCES_FOR_ACTION_ENUMERATE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAction</type> <name>action</name></member> + </type> + + <type category="struct" name="XrInputSourceLocalizedNameGetInfo"> + <member values="XR_TYPE_INPUT_SOURCE_LOCALIZED_NAME_GET_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPath</type> <name>sourcePath</name></member> + <member><type>XrInputSourceLocalizedNameFlags</type> <name>whichComponents</name></member> + </type> + + <type category="struct" name="XrEventDataInteractionProfileChanged" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSession</type> <name>session</name></member> + </type> + + <type category="struct" name="XrInteractionProfileState"> + <member values="XR_TYPE_INTERACTION_PROFILE_STATE"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrPath</type> <name>interactionProfile</name></member> + </type> + + <type category="struct" name="XrActionCreateInfo"> + <member values="XR_TYPE_ACTION_CREATE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>char</type> <name>actionName</name>[<enum>XR_MAX_ACTION_NAME_SIZE</enum>]</member> + <member><type>XrActionType</type> <name>actionType</name></member> + <member optional="true"><type>uint32_t</type> <name>countSubactionPaths</name></member> + <member len="countSubactionPaths" optional="true">const <type>XrPath</type>* <name>subactionPaths</name></member> + <member><type>char</type> <name>localizedActionName</name>[<enum>XR_MAX_LOCALIZED_ACTION_NAME_SIZE</enum>]</member> + </type> + <type category="struct" name="XrInstanceCreateInfoAndroidKHR" structextends="XrInstanceCreateInfo"> + <member values="XR_TYPE_INSTANCE_CREATE_INFO_ANDROID_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>void</type>* <name>applicationVM</name></member> + <member><type>void</type>* <name>applicationActivity</name></member> + </type> + <type category="struct" name="XrVulkanSwapchainFormatListCreateInfoKHR" structextends="XrSwapchainCreateInfo"> + <member values="XR_TYPE_VULKAN_SWAPCHAIN_FORMAT_LIST_CREATE_INFO_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>viewFormatCount</name></member> + <member len="viewFormatCount">const <type>VkFormat</type>* <name>viewFormats</name></member> + </type> + <type category="struct" name="XrDebugUtilsObjectNameInfoEXT"> + <member values="XR_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrObjectType</type> <name>objectType</name></member> + <member><type>uint64_t</type> <name>objectHandle</name></member> + <member optional="true" len="null-terminated">const <type>char</type>* <name>objectName</name></member> + </type> + <type category="struct" name="XrDebugUtilsLabelEXT"> + <member values="XR_TYPE_DEBUG_UTILS_LABEL_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member len="null-terminated">const <type>char</type>* <name>labelName</name></member> + </type> + <type category="struct" name="XrDebugUtilsMessengerCallbackDataEXT"> + <member values="XR_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true" len="null-terminated">const <type>char</type>* <name>messageId</name></member> + <member optional="true" len="null-terminated">const <type>char</type>* <name>functionName</name></member> + <member len="null-terminated">const <type>char</type>* <name>message</name></member> + <member optional="true"><type>uint32_t</type> <name>objectCount</name></member> + <member noautovalidity="true" optional="true" len="objectCount"><type>XrDebugUtilsObjectNameInfoEXT</type>* <name>objects</name></member> + <member optional="true"><type>uint32_t</type> <name>sessionLabelCount</name></member> + <member noautovalidity="true" optional="true" len="sessionLabelCount"><type>XrDebugUtilsLabelEXT</type>* <name>sessionLabels</name></member> + </type> + <type category="struct" name="XrDebugUtilsMessengerCreateInfoEXT" structextends="XrInstanceCreateInfo"> + <member values="XR_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrDebugUtilsMessageSeverityFlagsEXT</type> <name>messageSeverities</name></member> + <member><type>XrDebugUtilsMessageTypeFlagsEXT</type> <name>messageTypes</name></member> + <member><type>PFN_xrDebugUtilsMessengerCallbackEXT</type> <name>userCallback</name></member> + <member optional="true"><type>void</type>* <name>userData</name></member> + </type> + + <!-- struct types for XR_KHR_visibility_mask --> + <type category="struct" name="XrVisibilityMaskKHR"> + <member values="XR_TYPE_VISIBILITY_MASK_KHR"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCountOutput</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector2f</type>* <name>vertices</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCountOutput</name></member> + <member optional="true" len="indexCapacityInput"><type>uint32_t</type>* <name>indices</name></member> + </type> + + <type category="struct" name="XrGraphicsRequirementsOpenGLKHR"> + <member values="XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_KHR"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrVersion</type> <name>minApiVersionSupported</name></member> + <member><type>XrVersion</type> <name>maxApiVersionSupported</name></member> + </type> + <type category="struct" name="XrGraphicsRequirementsOpenGLESKHR"> + <member values="XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_ES_KHR"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrVersion</type> <name>minApiVersionSupported</name></member> + <member><type>XrVersion</type> <name>maxApiVersionSupported</name></member> + </type> + <type category="struct" name="XrGraphicsRequirementsVulkanKHR"> + <member values="XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrVersion</type> <name>minApiVersionSupported</name></member> + <member><type>XrVersion</type> <name>maxApiVersionSupported</name></member> + </type> + <type category="struct" name="XrGraphicsRequirementsD3D11KHR"> + <member values="XR_TYPE_GRAPHICS_REQUIREMENTS_D3D11_KHR"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>LUID</type> <name>adapterLuid</name></member> + <member><type>D3D_FEATURE_LEVEL</type> <name>minFeatureLevel</name></member> + </type> + <type category="struct" name="XrGraphicsRequirementsD3D12KHR"> + <member values="XR_TYPE_GRAPHICS_REQUIREMENTS_D3D12_KHR"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>LUID</type> <name>adapterLuid</name></member> + <member><type>D3D_FEATURE_LEVEL</type> <name>minFeatureLevel</name></member> + </type> + <type category="struct" name="XrGraphicsRequirementsMetalKHR"> + <member values="XR_TYPE_GRAPHICS_REQUIREMENTS_METAL_KHR"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>void</type>* <name>metalDevice</name></member> + </type> + + <!-- XR_KHR_vulkan_enable2 structs --> + <type category="struct" name="XrVulkanInstanceCreateInfoKHR"> + <member values="XR_TYPE_VULKAN_INSTANCE_CREATE_INFO_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSystemId</type> <name>systemId</name></member> + <member optional="true"><type>XrVulkanInstanceCreateFlagsKHR</type> <name>createFlags</name></member> + <member><type>PFN_vkGetInstanceProcAddr</type> <name>pfnGetInstanceProcAddr</name></member> + <member>const <type>VkInstanceCreateInfo</type>* <name>vulkanCreateInfo</name></member> + <member optional="true">const <type>VkAllocationCallbacks</type>* <name>vulkanAllocator</name></member> + </type> + <type category="struct" name="XrVulkanDeviceCreateInfoKHR"> + <member values="XR_TYPE_VULKAN_DEVICE_CREATE_INFO_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSystemId</type> <name>systemId</name></member> + <member optional="true"><type>XrVulkanDeviceCreateFlagsKHR</type> <name>createFlags</name></member> + <member><type>PFN_vkGetInstanceProcAddr</type> <name>pfnGetInstanceProcAddr</name></member> + <member><type>VkPhysicalDevice</type> <name>vulkanPhysicalDevice</name></member> + <member>const <type>VkDeviceCreateInfo</type>* <name>vulkanCreateInfo</name></member> + <member optional="true">const <type>VkAllocationCallbacks</type>* <name>vulkanAllocator</name></member> + </type> + <type category="struct" name="XrGraphicsBindingVulkan2KHR" alias="XrGraphicsBindingVulkanKHR"/> + <type category="struct" name="XrVulkanGraphicsDeviceGetInfoKHR"> + <member values="XR_TYPE_VULKAN_GRAPHICS_DEVICE_GET_INFO_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSystemId</type> <name>systemId</name></member> + <member><type>VkInstance</type> <name>vulkanInstance</name></member> + </type> + <type category="struct" name="XrSwapchainImageVulkan2KHR" alias="XrSwapchainImageVulkanKHR"/> + <type category="struct" name="XrGraphicsRequirementsVulkan2KHR" alias="XrGraphicsRequirementsVulkanKHR"/> + + <!-- XR_META_vulkan_swapchain_create_info structs --> + <type category="struct" name="XrVulkanSwapchainCreateInfoMETA" structextends="XrSwapchainCreateInfo"> + <member values="XR_TYPE_VULKAN_SWAPCHAIN_CREATE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>VkImageCreateFlags</type> <name>additionalCreateFlags</name></member> + <member><type>VkImageUsageFlags</type> <name>additionalUsageFlags</name></member> + </type> + + <!-- XR_EXTX_overlay structs --> + <type category="struct" name="XrSessionCreateInfoOverlayEXTX" structextends="XrSessionCreateInfo"> + <member values="XR_TYPE_SESSION_CREATE_INFO_OVERLAY_EXTX"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrOverlaySessionCreateFlagsEXTX</type> <name>createFlags</name></member> + <member><type>uint32_t</type> <name>sessionLayersPlacement</name></member> + </type> + <type category="struct" name="XrEventDataMainSessionVisibilityChangedEXTX" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_MAIN_SESSION_VISIBILITY_CHANGED_EXTX"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>visible</name></member> + <member><type>XrOverlayMainSessionFlagsEXTX</type> <name>flags</name></member> + </type> + + <!-- XR_FB_display_refresh_rate structs --> + <type category="struct" name="XrEventDataDisplayRefreshRateChangedFB" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>fromDisplayRefreshRate</name></member> + <member><type>float</type> <name>toDisplayRefreshRate</name></member> + </type> + + <!-- struct types for XR_EXT_view_configuration_depth_range --> + <type category="struct" name="XrViewConfigurationDepthRangeEXT" structextends="XrViewConfigurationView"> + <member values="XR_TYPE_VIEW_CONFIGURATION_DEPTH_RANGE_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>float</type> <name>recommendedNearZ</name></member> + <member><type>float</type> <name>minNearZ</name></member> + <member><type>float</type> <name>recommendedFarZ</name></member> + <member><type>float</type> <name>maxFarZ</name></member> + </type> + + <!-- struct types for XR_EPIC_view_configuration_fov --> + <type category="struct" name="XrViewConfigurationViewFovEPIC" structextends="XrViewConfigurationView"> + <member values="XR_TYPE_VIEW_CONFIGURATION_VIEW_FOV_EPIC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrFovf</type> <name>recommendedFov</name></member> + <member><type>XrFovf</type> <name>maxMutableFov</name></member> + </type> + + <!-- struct types for XR_EXT_dpad_binding --> + <type category="struct" name="XrInteractionProfileDpadBindingEXT" parentstruct="XrBindingModificationBaseHeaderKHR"> + <member values="XR_TYPE_INTERACTION_PROFILE_DPAD_BINDING_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPath</type> <name>binding</name></member> + <member><type>XrActionSet</type> <name>actionSet</name></member> + <member><type>float</type> <name>forceThreshold</name></member> + <member><type>float</type> <name>forceThresholdReleased</name></member> + <member><type>float</type> <name>centerRegion</name></member> + <member><type>float</type> <name>wedgeAngle</name></member> + <member><type>XrBool32</type> <name>isSticky</name></member> + <member optional="true">const <type>XrHapticBaseHeader</type>* <name>onHaptic</name></member> + <member optional="true">const <type>XrHapticBaseHeader</type>* <name>offHaptic</name></member> + </type> + + <!-- struct types for XR_VALVE_analog_threshold --> + <type category="struct" name="XrInteractionProfileAnalogThresholdVALVE" parentstruct="XrBindingModificationBaseHeaderKHR"> + <member values="XR_TYPE_INTERACTION_PROFILE_ANALOG_THRESHOLD_VALVE"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAction</type> <name>action</name></member> + <member><type>XrPath</type> <name>binding</name></member> + <member><type>float</type> <name>onThreshold</name></member> + <member><type>float</type> <name>offThreshold</name></member> + <member optional="true">const <type>XrHapticBaseHeader</type>* <name>onHaptic</name></member> + <member optional="true">const <type>XrHapticBaseHeader</type>* <name>offHaptic</name></member> + </type> + + <!-- struct types for XR_KHR_binding_modification --> + <type category="struct" name="XrBindingModificationsKHR" structextends="XrInteractionProfileSuggestedBinding"> + <member values="XR_TYPE_BINDING_MODIFICATIONS_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>bindingModificationCount</name></member> + <member optional="true" len="bindingModificationCount">const <type>XrBindingModificationBaseHeaderKHR</type>* const* <name>bindingModifications</name></member> + </type> + + <type category="struct" name="XrBindingModificationBaseHeaderKHR"> + <member noautovalidity="true"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <!-- The PFN_xrVoidFunction type is used by xrGetInstanceProcAddr below --> + <type category="funcpointer">typedef void (XRAPI_PTR *<name>PFN_xrVoidFunction</name>)(void);</type> + + <!-- The PFN_xrGetInstanceProcAddr type is used by XrNegotiateRuntimeRequest below --> + <type category="funcpointer">typedef XrResult (XRAPI_PTR *<name>PFN_xrGetInstanceProcAddr</name>)(XrInstance instance, const char* name, PFN_xrVoidFunction* function);</type> + + <!-- openxr_loader_negotiation.h --> + <!-- Function pointer prototype for the xrCreateApiLayerInstance function used in place of xrCreateInstance. --> + <!-- This function allows us to pass special API layer information to each layer during the process of creating an Instance. --> + <!-- The typedef is embedded to work around circular dependency between XrApiLayerCreateInfo, next and PFN_xrCreateApiLayerInstance --> + <type category="funcpointer"> +typedef struct XrApiLayerCreateInfo XrApiLayerCreateInfo; +typedef XrResult (XRAPI_PTR *<name>PFN_xrCreateApiLayerInstance</name>)( + const XrInstanceCreateInfo* info, + const XrApiLayerCreateInfo* apiLayerInfo, + XrInstance* instance);</type> + + <!-- The PFN_xrDebugUtilsMessengerCallbackEXT type are used by the XR_EXT_debug_utils extension --> + <type category="funcpointer" requires="XrDebugUtilsMessengerCallbackDataEXT">typedef XrBool32 (XRAPI_PTR *<name>PFN_xrDebugUtilsMessengerCallbackEXT</name>)( + <type>XrDebugUtilsMessageSeverityFlagsEXT</type> messageSeverity, + <type>XrDebugUtilsMessageTypeFlagsEXT</type> messageTypes, + const <type>XrDebugUtilsMessengerCallbackDataEXT</type>* callbackData, + <type>void</type>* userData); + </type> + + <!-- types for XR_EXT_eye_gaze_interaction --> + <type category="struct" name="XrSystemEyeGazeInteractionPropertiesEXT" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_EYE_GAZE_INTERACTION_PROPERTIES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsEyeGazeInteraction</name></member> + </type> + + <type category="struct" name="XrEyeGazeSampleTimeEXT" structextends="XrSpaceLocation"> + <member values="XR_TYPE_EYE_GAZE_SAMPLE_TIME_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <!-- XR_EXT_frame_synthesis --> + <type category="struct" name="XrFrameSynthesisInfoEXT" structextends="XrCompositionLayerProjectionView"> + <member values="XR_TYPE_FRAME_SYNTHESIS_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrFrameSynthesisInfoFlagsEXT</type> <name>layerFlags</name></member> + <member><type>XrSwapchainSubImage</type> <name>motionVectorSubImage</name></member> + <member><type>XrVector4f</type> <name>motionVectorScale</name></member> + <member><type>XrVector4f</type> <name>motionVectorOffset</name></member> + <member><type>XrPosef</type> <name>appSpaceDeltaPose</name></member> + <member><type>XrSwapchainSubImage</type> <name>depthSubImage</name></member> + <member><type>float</type> <name>minDepth</name></member> + <member><type>float</type> <name>maxDepth</name></member> + <member><type>float</type> <name>nearZ</name></member> + <member><type>float</type> <name>farZ</name></member> + </type> + + <type category="struct" name="XrFrameSynthesisConfigViewEXT" structextends="XrViewConfigurationView"> + <member values="XR_TYPE_FRAME_SYNTHESIS_CONFIG_VIEW_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>recommendedMotionVectorImageRectWidth</name></member> + <member><type>uint32_t</type> <name>recommendedMotionVectorImageRectHeight</name></member> + </type> + + <!-- types for XR_MSFT_spatial_anchor --> + <type category="struct" name="XrSpatialAnchorCreateInfoMSFT"> + <member values="XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrSpatialAnchorSpaceCreateInfoMSFT"> + <member values="XR_TYPE_SPATIAL_ANCHOR_SPACE_CREATE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialAnchorMSFT</type> <name>anchor</name></member> + <member><type>XrPosef</type> <name>poseInAnchorSpace</name></member> + </type> + + <!-- types for XR_FB_composition_layer_image_layout --> + <type category="struct" name="XrCompositionLayerImageLayoutFB" structextends="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_IMAGE_LAYOUT_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrCompositionLayerImageLayoutFlagsFB</type> <name>flags</name></member> + </type> + + <!-- types for XR_FB_composition_layer_alpha_blend --> + <type category="struct" name="XrCompositionLayerAlphaBlendFB" structextends="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_ALPHA_BLEND_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBlendFactorFB</type> <name>srcFactorColor</name></member> + <member><type>XrBlendFactorFB</type> <name>dstFactorColor</name></member> + <member><type>XrBlendFactorFB</type> <name>srcFactorAlpha</name></member> + <member><type>XrBlendFactorFB</type> <name>dstFactorAlpha</name></member> + </type> + + + <!-- types for XR_MNDX_egl_enable --> + <type category="funcpointer">typedef PFN_xrVoidFunction (*<name>PFN_xrEglGetProcAddressMNDX</name>)(const <type>char</type> *name);</type> + + <type category="struct" name="XrGraphicsBindingEGLMNDX" structextends="XrSessionCreateInfo"> + <member values="XR_TYPE_GRAPHICS_BINDING_EGL_MNDX"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>PFN_xrEglGetProcAddressMNDX</type> <name>getProcAddress</name></member> + <member><type>EGLDisplay</type> <name>display</name></member> + <member><type>EGLConfig</type> <name>config</name></member> + <member><type>EGLContext</type> <name>context</name></member> + </type> + + <!-- types for XR_MSFT_spatial_graph_bridge --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSpatialGraphNodeBindingMSFT</name>)</type> + <type category="struct" name="XrSpatialGraphNodeSpaceCreateInfoMSFT"> + <member values="XR_TYPE_SPATIAL_GRAPH_NODE_SPACE_CREATE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialGraphNodeTypeMSFT</type> <name>nodeType</name></member> + <member><type>uint8_t</type> <name>nodeId</name>[<enum>XR_GUID_SIZE_MSFT</enum>]</member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrSpatialGraphStaticNodeBindingCreateInfoMSFT"> + <member values="XR_TYPE_SPATIAL_GRAPH_STATIC_NODE_BINDING_CREATE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrPosef</type> <name>poseInSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrSpatialGraphNodeBindingPropertiesGetInfoMSFT"> + <member values="XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_GET_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrSpatialGraphNodeBindingPropertiesMSFT"> + <member values="XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint8_t</type> <name>nodeId</name>[<enum>XR_GUID_SIZE_MSFT</enum>]</member> + <member><type>XrPosef</type> <name>poseInNodeSpace</name></member> + </type> + + <!-- XR_EXT_hand_tracking --> + <type name="XrHandEXT" category="enum"/> + <type name="XrHandJointEXT" category="enum"/> + <type name="XrHandJointSetEXT" category="enum"/> + + <type category="struct" name="XrSystemHandTrackingPropertiesEXT" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_HAND_TRACKING_PROPERTIES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsHandTracking</name></member> + </type> + <type category="struct" name="XrHandTrackerCreateInfoEXT"> + <member values="XR_TYPE_HAND_TRACKER_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrHandEXT</type> <name>hand</name></member> + <member><type>XrHandJointSetEXT</type> <name>handJointSet</name></member> + </type> + <type category="struct" name="XrHandJointsLocateInfoEXT"> + <member values="XR_TYPE_HAND_JOINTS_LOCATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrHandJointLocationEXT"> + <member optional="true"><type>XrSpaceLocationFlags</type> <name>locationFlags</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>float</type> <name>radius</name></member> + </type> + <type category="struct" name="XrHandJointVelocityEXT" returnedonly="true"> + <member optional="true"><type>XrSpaceVelocityFlags</type> <name>velocityFlags</name></member> + <member><type>XrVector3f</type> <name>linearVelocity</name></member> + <member><type>XrVector3f</type> <name>angularVelocity</name></member> + </type> + <type category="struct" name="XrHandJointLocationsEXT"> + <member values="XR_TYPE_HAND_JOINT_LOCATIONS_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>isActive</name></member> + <member><type>uint32_t</type> <name>jointCount</name></member> + <member len="jointCount"><type>XrHandJointLocationEXT</type>* <name>jointLocations</name></member> + </type> + <type category="struct" name="XrHandJointVelocitiesEXT" structextends="XrHandJointLocationsEXT"> + <member values="XR_TYPE_HAND_JOINT_VELOCITIES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>jointCount</name></member> + <member len="jointCount"><type>XrHandJointVelocityEXT</type>* <name>jointVelocities</name></member> + </type> + + <!-- XR_FB_face_tracking structs --> + <type category="struct" name="XrSystemFaceTrackingPropertiesFB" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsFaceTracking</name></member> + </type> + <type category="struct" name="XrFaceTrackerCreateInfoFB"> + <member values="XR_TYPE_FACE_TRACKER_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrFaceExpressionSetFB</type> <name>faceExpressionSet</name></member> + </type> + <type category="struct" name="XrFaceExpressionInfoFB"> + <member values="XR_TYPE_FACE_EXPRESSION_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrFaceExpressionStatusFB"> + <member><type>XrBool32</type> <name>isValid</name></member> + <member><type>XrBool32</type> <name>isEyeFollowingBlendshapesValid</name></member> + </type> + <type category="struct" name="XrFaceExpressionWeightsFB"> + <member values="XR_TYPE_FACE_EXPRESSION_WEIGHTS_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>weightCount</name></member> + <member len="weightCount"><type>float</type>* <name>weights</name></member> + <member><type>uint32_t</type> <name>confidenceCount</name></member> + <member len="confidenceCount"><type>float</type>* <name>confidences</name></member> + <member><type>XrFaceExpressionStatusFB</type> <name>status</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <!-- XR_FB_face_tracking2 structs --> + <type category="struct" name="XrSystemFaceTrackingProperties2FB" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES2_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsVisualFaceTracking</name></member> + <member><type>XrBool32</type> <name>supportsAudioFaceTracking</name></member> + </type> + <type category="struct" name="XrFaceTrackerCreateInfo2FB"> + <member values="XR_TYPE_FACE_TRACKER_CREATE_INFO2_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrFaceExpressionSet2FB</type> <name>faceExpressionSet</name></member> + <member optional="true"><type>uint32_t</type> <name>requestedDataSourceCount</name></member> + <member optional="true" len="requestedDataSourceCount"><type>XrFaceTrackingDataSource2FB</type>* <name>requestedDataSources</name></member> + </type> + <type category="struct" name="XrFaceExpressionInfo2FB"> + <member values="XR_TYPE_FACE_EXPRESSION_INFO2_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrFaceExpressionWeights2FB"> + <member values="XR_TYPE_FACE_EXPRESSION_WEIGHTS2_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>weightCount</name></member> + <member len="weightCount"><type>float</type>* <name>weights</name></member> + <member><type>uint32_t</type> <name>confidenceCount</name></member> + <member len="confidenceCount"><type>float</type>* <name>confidences</name></member> + <member><type>XrBool32</type> <name>isValid</name></member> + <member><type>XrBool32</type> <name>isEyeFollowingBlendshapesValid</name></member> + <member><type>XrFaceTrackingDataSource2FB</type> <name>dataSource</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <!-- XR_META_face_tracking_visemes--> + <type category="struct" name="XrSystemFaceTrackingVisemesPropertiesMETA" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_FACE_TRACKING_VISEMES_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsVisemes</name></member> + </type> + <type category="struct" name="XrFaceTrackingVisemesMETA" structextends="XrFaceExpressionWeights2FB"> + <member values="XR_TYPE_FACE_TRACKING_VISEMES_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>isValid</name></member> + <member><type>float</type> <name>visemes</name>[<enum>XR_FACE_TRACKING_VISEME_COUNT_META</enum>]</member> + </type> + + <!-- XR_FB_body_tracking structs --> + <type category="struct" name="XrSystemBodyTrackingPropertiesFB" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsBodyTracking</name></member> + </type> + <type category="struct" name="XrBodyTrackerCreateInfoFB"> + <member values="XR_TYPE_BODY_TRACKER_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBodyJointSetFB</type> <name>bodyJointSet</name></member> + </type> + <type category="struct" name="XrBodySkeletonJointFB"> + <member><type>int32_t</type> <name>joint</name></member> + <member><type>int32_t</type> <name>parentJoint</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrBodySkeletonFB"> + <member values="XR_TYPE_BODY_SKELETON_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>jointCount</name></member> + <member len="jointCount"><type>XrBodySkeletonJointFB</type>* <name>joints</name></member> + </type> + <type category="struct" name="XrBodyJointsLocateInfoFB"> + <member values="XR_TYPE_BODY_JOINTS_LOCATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrBodyJointLocationFB"> + <member><type>XrSpaceLocationFlags</type> <name>locationFlags</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrBodyJointLocationsFB" returnedonly="true"> + <member values="XR_TYPE_BODY_JOINT_LOCATIONS_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>isActive</name></member> + <member><type>float</type> <name>confidence</name></member> + <member><type>uint32_t</type> <name>jointCount</name></member> + <member len="jointCount"><type>XrBodyJointLocationFB</type>* <name>jointLocations</name></member> + <member><type>uint32_t</type> <name>skeletonChangedCount</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <!-- XR_META_body_tracking_full_body structs --> + <type category="struct" name="XrSystemPropertiesBodyTrackingFullBodyMETA" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_FULL_BODY_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsFullBodyTracking</name></member> + </type> + + <!-- XR_META_body_tracking_calibration structs --> + <type name="XrBodyTrackingCalibrationInfoMETA" category="struct"> + <member values="XR_TYPE_BODY_TRACKING_CALIBRATION_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>bodyHeight</name></member> + </type> + + <type name="XrBodyTrackingCalibrationStatusMETA" category="struct" structextends="XrBodyJointLocationsFB" returnedonly="true"> + <member values="XR_TYPE_BODY_TRACKING_CALIBRATION_STATUS_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBodyTrackingCalibrationStateMETA</type> <name>status</name></member> + </type> + + <type name="XrSystemPropertiesBodyTrackingCalibrationMETA" category="struct" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_CALIBRATION_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsHeightOverride</name></member> + </type> + + <!-- XR_META_body_tracking_fidelity structs --> + <type name="XrBodyTrackingFidelityStatusMETA" category="struct" structextends="XrBodyJointLocationsFB" returnedonly="true"> + <member values="XR_TYPE_BODY_TRACKING_FIDELITY_STATUS_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBodyTrackingFidelityMETA</type> <name>fidelity</name></member> + </type> + + <type name="XrSystemPropertiesBodyTrackingFidelityMETA" category="struct" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_FIDELITY_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsBodyTrackingFidelity</name></member> + </type> + + <!-- XR_FB_eye_tracking_social structs --> + <type category="struct" name="XrSystemEyeTrackingPropertiesFB" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_EYE_TRACKING_PROPERTIES_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsEyeTracking</name></member> + </type> + <type category="struct" name="XrEyeTrackerCreateInfoFB"> + <member values="XR_TYPE_EYE_TRACKER_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrEyeGazesInfoFB"> + <member values="XR_TYPE_EYE_GAZES_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrEyeGazeFB"> + <member><type>XrBool32</type> <name>isValid</name></member> + <member><type>XrPosef</type> <name>gazePose</name></member> + <member><type>float</type> <name>gazeConfidence</name></member> + </type> + <type category="struct" name="XrEyeGazesFB"> + <member values="XR_TYPE_EYE_GAZES_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrEyeGazeFB</type> <name>gaze</name>[XR_EYE_POSITION_COUNT_FB]</member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <!-- XR_EXT_hand_joints_motion_range --> + <type name="XrHandJointsMotionRangeEXT" category="enum"/> + <type category="struct" name="XrHandJointsMotionRangeInfoEXT" structextends="XrHandJointsLocateInfoEXT"> + <member values="XR_TYPE_HAND_JOINTS_MOTION_RANGE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrHandJointsMotionRangeEXT</type> <name>handJointsMotionRange</name></member> + </type> + + <!-- XR_EXT_hand_tracking_data_source --> + <type name="XrHandTrackingDataSourceEXT" category="enum"/> + <type category="struct" name="XrHandTrackingDataSourceInfoEXT" structextends="XrHandTrackerCreateInfoEXT"> + <member values="XR_TYPE_HAND_TRACKING_DATA_SOURCE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>requestedDataSourceCount</name></member> + <member len="requestedDataSourceCount"><type>XrHandTrackingDataSourceEXT</type>* <name>requestedDataSources</name></member> + </type> + + <type category="struct" name="XrHandTrackingDataSourceStateEXT" structextends="XrHandJointLocationsEXT" returnedonly="true"> + <member values="XR_TYPE_HAND_TRACKING_DATA_SOURCE_STATE_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>isActive</name></member> + <member optional="true"><type>XrHandTrackingDataSourceEXT</type> <name>dataSource</name></member> + </type> + + <!-- XR_MSFT_hand_tracking_mesh --> + <type name="XrHandPoseTypeMSFT" category="enum"/> + <type category="struct" name="XrHandMeshSpaceCreateInfoMSFT"> + <member values="XR_TYPE_HAND_MESH_SPACE_CREATE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrHandPoseTypeMSFT</type> <name>handPoseType</name></member> + <member><type>XrPosef</type> <name>poseInHandMeshSpace</name></member> + </type> + <type category="struct" name="XrHandMeshUpdateInfoMSFT"> + <member values="XR_TYPE_HAND_MESH_UPDATE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrHandPoseTypeMSFT</type> <name>handPoseType</name></member> + </type> + <type category="struct" name="XrHandMeshMSFT"> + <member values="XR_TYPE_HAND_MESH_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>isActive</name></member> + <member><type>XrBool32</type> <name>indexBufferChanged</name></member> + <member><type>XrBool32</type> <name>vertexBufferChanged</name></member> + <member><type>XrHandMeshIndexBufferMSFT</type> <name>indexBuffer</name></member> + <member><type>XrHandMeshVertexBufferMSFT</type> <name>vertexBuffer</name></member> + </type> + <type category="struct" name="XrHandMeshIndexBufferMSFT"> + <member optional="true"><type>uint32_t</type> <name>indexBufferKey</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCountOutput</name></member> + <member optional="true" len="indexCapacityInput"><type>uint32_t</type>* <name>indices</name></member> + </type> + <type category="struct" name="XrHandMeshVertexBufferMSFT"> + <member optional="true"><type>XrTime</type> <name>vertexUpdateTime</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCountOutput</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrHandMeshVertexMSFT</type>* <name>vertices</name></member> + </type> + <type category="struct" name="XrHandMeshVertexMSFT"> + <member><type>XrVector3f</type> <name>position</name></member> + <member><type>XrVector3f</type> <name>normal</name></member> + </type> + <type category="struct" name="XrSystemHandTrackingMeshPropertiesMSFT" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_HAND_TRACKING_MESH_PROPERTIES_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsHandTrackingMesh</name></member> + <member><type>uint32_t</type> <name>maxHandMeshIndexCount</name></member> + <member><type>uint32_t</type> <name>maxHandMeshVertexCount</name></member> + </type> + <type category="struct" name="XrHandPoseTypeInfoMSFT" structextends="XrHandTrackerCreateInfoEXT"> + <member values="XR_TYPE_HAND_POSE_TYPE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrHandPoseTypeMSFT</type> <name>handPoseType</name></member> + </type> + + <!-- XR_MSFT_secondary_view_configuration --> + <type category="struct" name="XrSecondaryViewConfigurationSessionBeginInfoMSFT" structextends="XrSessionBeginInfo"> + <member values="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_SESSION_BEGIN_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>viewConfigurationCount</name></member> + <member len="viewConfigurationCount">const <type>XrViewConfigurationType</type>* <name>enabledViewConfigurationTypes</name></member> + </type> + <type category="struct" name="XrSecondaryViewConfigurationStateMSFT"> + <member values="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_STATE_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></member> + <member><type>XrBool32</type> <name>active</name></member> + </type> + <type category="struct" name="XrSecondaryViewConfigurationFrameStateMSFT" structextends="XrFrameState"> + <member values="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_FRAME_STATE_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>viewConfigurationCount</name></member> + <member len="viewConfigurationCount"><type>XrSecondaryViewConfigurationStateMSFT</type>* <name>viewConfigurationStates</name></member> + </type> + <type category="struct" name="XrSecondaryViewConfigurationFrameEndInfoMSFT" structextends="XrFrameEndInfo"> + <member values="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_FRAME_END_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>viewConfigurationCount</name></member> + <member len="viewConfigurationCount">const <type>XrSecondaryViewConfigurationLayerInfoMSFT</type>* <name>viewConfigurationLayersInfo</name></member> + </type> + <type category="struct" name="XrSecondaryViewConfigurationLayerInfoMSFT"> + <member values="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_LAYER_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></member> + <member><type>XrEnvironmentBlendMode</type> <name>environmentBlendMode</name></member> + <member><type>uint32_t</type> <name>layerCount</name></member> + <member len="layerCount">const <type>XrCompositionLayerBaseHeader</type>* const* <name>layers</name></member> + </type> + <type category="struct" name="XrSecondaryViewConfigurationSwapchainCreateInfoMSFT" structextends="XrSwapchainCreateInfo"> + <member values="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_SWAPCHAIN_CREATE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></member> + </type> + + <!-- XR_MSFT_holographic_window_attachment --> + <type category="struct" name="XrHolographicWindowAttachmentMSFT" structextends="XrSessionCreateInfo" protect="XR_USE_PLATFORM_WIN32"> + <member values="XR_TYPE_HOLOGRAPHIC_WINDOW_ATTACHMENT_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>IUnknown</type>* <name>holographicSpace</name></member> + <member><type>IUnknown</type>* <name>coreWindow</name></member> + </type> + + <!-- XR_FB_android_surface_swapchain_create --> + <type category="struct" name="XrAndroidSurfaceSwapchainCreateInfoFB" structextends="XrSwapchainCreateInfo" protect="XR_USE_PLATFORM_ANDROID"> + <member values="XR_TYPE_ANDROID_SURFACE_SWAPCHAIN_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAndroidSurfaceSwapchainFlagsFB</type> <name>createFlags</name></member> + </type> + + <!-- XR_FB_swapchain_update_state structs --> + <type category="struct" name="XrSwapchainStateBaseHeaderFB"> + <member><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + </type> + + <!-- XR_FB_swapchain_update_state_android_surface structs --> + <type category="struct" name="XrSwapchainStateAndroidSurfaceDimensionsFB" parentstruct="XrSwapchainStateBaseHeaderFB" protect="XR_USE_PLATFORM_ANDROID"> + <member values="XR_TYPE_SWAPCHAIN_STATE_ANDROID_SURFACE_DIMENSIONS_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>width</name></member> + <member><type>uint32_t</type> <name>height</name></member> + </type> + + <!-- XR_FB_swapchain_update_state_opengl_es structs --> + <type category="struct" name="XrSwapchainStateSamplerOpenGLESFB" parentstruct="XrSwapchainStateBaseHeaderFB" protect="XR_USE_GRAPHICS_API_OPENGL_ES"> + <member values="XR_TYPE_SWAPCHAIN_STATE_SAMPLER_OPENGL_ES_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>EGLenum</type> <name>minFilter</name></member> + <member><type>EGLenum</type> <name>magFilter</name></member> + <member><type>EGLenum</type> <name>wrapModeS</name></member> + <member><type>EGLenum</type> <name>wrapModeT</name></member> + <member><type>EGLenum</type> <name>swizzleRed</name></member> + <member><type>EGLenum</type> <name>swizzleGreen</name></member> + <member><type>EGLenum</type> <name>swizzleBlue</name></member> + <member><type>EGLenum</type> <name>swizzleAlpha</name></member> + <member><type>float</type> <name>maxAnisotropy</name></member> + <member><type>XrColor4f</type> <name>borderColor</name></member> + </type> + + <!-- XR_FB_swapchain_update_state_vulkan structs --> + <type category="struct" name="XrSwapchainStateSamplerVulkanFB" parentstruct="XrSwapchainStateBaseHeaderFB" protect="XR_USE_GRAPHICS_API_VULKAN"> + <member values="XR_TYPE_SWAPCHAIN_STATE_SAMPLER_VULKAN_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>VkFilter</type> <name>minFilter</name></member> + <member><type>VkFilter</type> <name>magFilter</name></member> + <member><type>VkSamplerMipmapMode</type> <name>mipmapMode</name></member> + <member><type>VkSamplerAddressMode</type> <name>wrapModeS</name></member> + <member><type>VkSamplerAddressMode</type> <name>wrapModeT</name></member> + <member><type>VkComponentSwizzle</type> <name>swizzleRed</name></member> + <member><type>VkComponentSwizzle</type> <name>swizzleGreen</name></member> + <member><type>VkComponentSwizzle</type> <name>swizzleBlue</name></member> + <member><type>VkComponentSwizzle</type> <name>swizzleAlpha</name></member> + <member><type>float</type> <name>maxAnisotropy</name></member> + <member><type>XrColor4f</type> <name>borderColor</name></member> + </type> + + <!-- XR_FB_composition_layer_secure_content structs --> + <type category="struct" name="XrCompositionLayerSecureContentFB" structextends="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_SECURE_CONTENT_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCompositionLayerSecureContentFlagsFB</type> <name>flags</name></member> + </type> + + <!-- XR_KHR_loader_init --> + <type category="struct" name="XrLoaderInitInfoBaseHeaderKHR"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <!-- XR_KHR_loader_init_android --> + <type category="struct" name="XrLoaderInitInfoAndroidKHR" parentstruct="XrLoaderInitInfoBaseHeaderKHR"> + <member values="XR_TYPE_LOADER_INIT_INFO_ANDROID_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>void</type>* <name>applicationVM</name></member> + <member><type>void</type>* <name>applicationContext</name></member> + </type> + + <!-- XR_KHR_composition_layer_equirect2 --> + <type category="struct" name="XrCompositionLayerEquirect2KHR" parentstruct="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_EQUIRECT2_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrCompositionLayerFlags</type> <name>layerFlags</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrEyeVisibility</type> <name>eyeVisibility</name></member> + <member><type>XrSwapchainSubImage</type> <name>subImage</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>float</type> <name>radius</name></member> + <member><type>float</type> <name>centralHorizontalAngle</name></member> + <member><type>float</type> <name>upperVerticalAngle</name></member> + <member><type>float</type> <name>lowerVerticalAngle</name></member> + </type> + + <!-- XR_KHR_composition_layer_color_scale_bias --> + <type category="struct" name="XrCompositionLayerColorScaleBiasKHR" structextends="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_COLOR_SCALE_BIAS_KHR"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrColor4f</type> <name>colorScale</name></member> + <member><type>XrColor4f</type> <name>colorBias</name></member> + </type> + + <!-- XR_MSFT_controller_model --> + <type category="struct" name="XrControllerModelKeyStateMSFT"> + <member values="XR_TYPE_CONTROLLER_MODEL_KEY_STATE_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrControllerModelKeyMSFT</type> <name>modelKey</name></member> + </type> + <type category="struct" name="XrControllerModelNodePropertiesMSFT"> + <member values="XR_TYPE_CONTROLLER_MODEL_NODE_PROPERTIES_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>char</type> <name>parentNodeName</name>[<enum>XR_MAX_CONTROLLER_MODEL_NODE_NAME_SIZE_MSFT</enum>]</member> + <member><type>char</type> <name>nodeName</name>[<enum>XR_MAX_CONTROLLER_MODEL_NODE_NAME_SIZE_MSFT</enum>]</member> + </type> + <type category="struct" name="XrControllerModelPropertiesMSFT"> + <member values="XR_TYPE_CONTROLLER_MODEL_PROPERTIES_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>nodeCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>nodeCountOutput</name></member> + <member optional="true" len="nodeCapacityInput"><type>XrControllerModelNodePropertiesMSFT</type>* <name>nodeProperties</name></member> + </type> + <type category="struct" name="XrControllerModelNodeStateMSFT"> + <member values="XR_TYPE_CONTROLLER_MODEL_NODE_STATE_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrPosef</type> <name>nodePose</name></member> + </type> + <type category="struct" name="XrControllerModelStateMSFT"> + <member values="XR_TYPE_CONTROLLER_MODEL_STATE_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>nodeCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>nodeCountOutput</name></member> + <member optional="true" len="nodeCapacityInput"><type>XrControllerModelNodeStateMSFT</type>* <name>nodeStates</name></member> + </type> + + <!-- XR_MSFT_scene_understanding --> + <type category="handle" parent="XrSession"> + <type>XR_DEFINE_HANDLE</type>(<name>XrSceneObserverMSFT</name>)</type> + <type category="handle" parent="XrSceneObserverMSFT"> + <type>XR_DEFINE_HANDLE</type>(<name>XrSceneMSFT</name>)</type> + <type name="XrSceneObjectTypeMSFT" category="enum"/> + <type name="XrScenePlaneAlignmentTypeMSFT" category="enum"/> + <type name="XrSceneComputeStateMSFT" category="enum"/> + <type name="XrSceneComputeFeatureMSFT" category="enum"/> + <type name="XrSceneComputeConsistencyMSFT" category="enum"/> + <type name="XrSceneComponentTypeMSFT" category="enum"/> + <type name="XrMeshComputeLodMSFT" category="enum"/> + <type category="struct" name="XrUuidMSFT"> + <member><type>uint8_t</type> <name>bytes</name>[16]</member> + </type> + <type category="struct" name="XrSceneObserverCreateInfoMSFT"> + <member values="XR_TYPE_SCENE_OBSERVER_CREATE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrSceneCreateInfoMSFT"> + <member values="XR_TYPE_SCENE_CREATE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrNewSceneComputeInfoMSFT"> + <member values="XR_TYPE_NEW_SCENE_COMPUTE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>requestedFeatureCount</name></member> + <member len="requestedFeatureCount">const <type>XrSceneComputeFeatureMSFT</type>* <name>requestedFeatures</name></member> + <member><type>XrSceneComputeConsistencyMSFT</type> <name>consistency</name></member> + <member><type>XrSceneBoundsMSFT</type> <name>bounds</name></member> + </type> + <type category="struct" name="XrVisualMeshComputeLodInfoMSFT" structextends="XrNewSceneComputeInfoMSFT"> + <member values="XR_TYPE_VISUAL_MESH_COMPUTE_LOD_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrMeshComputeLodMSFT</type> <name>lod</name></member> + </type> + + <type category="struct" name="XrSceneSphereBoundMSFT"> + <member><type>XrVector3f</type> <name>center</name></member> + <member><type>float</type> <name>radius</name></member> + </type> + + <type category="struct" name="XrSceneOrientedBoxBoundMSFT"> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrVector3f</type> <name>extents</name></member> + </type> + + <type category="struct" name="XrSceneFrustumBoundMSFT"> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrFovf</type> <name>fov</name></member> + <member><type>float</type> <name>farDistance</name></member> + </type> + + <type category="struct" name="XrSceneBoundsMSFT"> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member optional="true"><type>uint32_t</type> <name>sphereCount</name></member> + <member optional="true" len="sphereCount">const <type>XrSceneSphereBoundMSFT</type>* <name>spheres</name></member> + <member optional="true"><type>uint32_t</type> <name>boxCount</name></member> + <member optional="true" len="boxCount">const <type>XrSceneOrientedBoxBoundMSFT</type>* <name>boxes</name></member> + <member optional="true"><type>uint32_t</type> <name>frustumCount</name></member> + <member optional="true" len="frustumCount">const <type>XrSceneFrustumBoundMSFT</type>* <name>frustums</name></member> + </type> + <type category="struct" name="XrSceneComponentMSFT"> + <member><type>XrSceneComponentTypeMSFT</type> <name>componentType</name></member> + <member><type>XrUuidMSFT</type> <name>id</name></member> + <member optional="true"><type>XrUuidMSFT</type> <name>parentId</name></member> + <member><type>XrTime</type> <name>updateTime</name></member> + </type> + <type category="struct" name="XrSceneComponentsMSFT"> + <member values="XR_TYPE_SCENE_COMPONENTS_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>componentCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>componentCountOutput</name></member> + <member optional="true" len="componentCapacityInput"><type>XrSceneComponentMSFT</type>* <name>components</name></member> + </type> + <type category="struct" name="XrSceneComponentsGetInfoMSFT"> + <member values="XR_TYPE_SCENE_COMPONENTS_GET_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSceneComponentTypeMSFT</type> <name>componentType</name></member> + </type> + <type category="struct" name="XrSceneComponentLocationMSFT"> + <member optional="true"><type>XrSpaceLocationFlags</type> <name>flags</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrSceneComponentLocationsMSFT"> + <member values="XR_TYPE_SCENE_COMPONENT_LOCATIONS_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>locationCount</name></member> + <member optional="true" len="locationCount"><type>XrSceneComponentLocationMSFT</type>* <name>locations</name></member> + </type> + <type category="struct" name="XrSceneComponentsLocateInfoMSFT"> + <member values="XR_TYPE_SCENE_COMPONENTS_LOCATE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member optional="true"><type>uint32_t</type> <name>componentIdCount</name></member> + <member optional="true" len="componentIdCount">const <type>XrUuidMSFT</type>* <name>componentIds</name></member> + </type> + <type category="struct" name="XrSceneObjectMSFT"> + <member><type>XrSceneObjectTypeMSFT</type> <name>objectType</name></member> + </type> + <type category="struct" name="XrSceneObjectsMSFT" structextends="XrSceneComponentsMSFT"> + <member values="XR_TYPE_SCENE_OBJECTS_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>sceneObjectCount</name></member> + <member optional="true" len="sceneObjectCount"><type>XrSceneObjectMSFT</type>* <name>sceneObjects</name></member> + </type> + <type category="struct" name="XrSceneComponentParentFilterInfoMSFT" structextends="XrSceneComponentsGetInfoMSFT"> + <member values="XR_TYPE_SCENE_COMPONENT_PARENT_FILTER_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrUuidMSFT</type> <name>parentId</name></member> + </type> + <type category="struct" name="XrSceneObjectTypesFilterInfoMSFT" structextends="XrSceneComponentsGetInfoMSFT"> + <member values="XR_TYPE_SCENE_OBJECT_TYPES_FILTER_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>objectTypeCount</name></member> + <member optional="true" len="objectTypeCount">const <type>XrSceneObjectTypeMSFT</type>* <name>objectTypes</name></member> + </type> + <type category="struct" name="XrScenePlaneMSFT"> + <member><type>XrScenePlaneAlignmentTypeMSFT</type> <name>alignment</name></member> + <member><type>XrExtent2Df</type> <name>size</name></member> + <member><type>uint64_t</type> <name>meshBufferId</name></member> + <member><type>XrBool32</type> <name>supportsIndicesUint16</name></member> + </type> + <type category="struct" name="XrScenePlanesMSFT" structextends="XrSceneComponentsMSFT"> + <member values="XR_TYPE_SCENE_PLANES_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>scenePlaneCount</name></member> + <member optional="true" len="scenePlaneCount"><type>XrScenePlaneMSFT</type>* <name>scenePlanes</name></member> + </type> + <type category="struct" name="XrScenePlaneAlignmentFilterInfoMSFT" structextends="XrSceneComponentsGetInfoMSFT"> + <member values="XR_TYPE_SCENE_PLANE_ALIGNMENT_FILTER_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>alignmentCount</name></member> + <member optional="true" len="alignmentCount">const <type>XrScenePlaneAlignmentTypeMSFT</type>* <name>alignments</name></member> + </type> + <type category="struct" name="XrSceneMeshMSFT"> + <member><type>uint64_t</type> <name>meshBufferId</name></member> + <member><type>XrBool32</type> <name>supportsIndicesUint16</name></member> + </type> + <type category="struct" name="XrSceneMeshesMSFT" structextends="XrSceneComponentsMSFT"> + <member values="XR_TYPE_SCENE_MESHES_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>sceneMeshCount</name></member> + <member optional="true" len="sceneMeshCount"><type>XrSceneMeshMSFT</type>* <name>sceneMeshes</name></member> + </type> + <type category="struct" name="XrSceneMeshBuffersGetInfoMSFT"> + <member values="XR_TYPE_SCENE_MESH_BUFFERS_GET_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint64_t</type> <name>meshBufferId</name></member> + </type> + <type category="struct" name="XrSceneMeshBuffersMSFT"> + <member values="XR_TYPE_SCENE_MESH_BUFFERS_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrSceneMeshVertexBufferMSFT" structextends="XrSceneMeshBuffersMSFT"> + <member values="XR_TYPE_SCENE_MESH_VERTEX_BUFFER_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCountOutput</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector3f</type>* <name>vertices</name></member> + </type> + <type category="struct" name="XrSceneMeshIndicesUint32MSFT" structextends="XrSceneMeshBuffersMSFT"> + <member values="XR_TYPE_SCENE_MESH_INDICES_UINT32_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCountOutput</name></member> + <member optional="true" len="indexCapacityInput"><type>uint32_t</type>* <name>indices</name></member> + </type> + <type category="struct" name="XrSceneMeshIndicesUint16MSFT" structextends="XrSceneMeshBuffersMSFT"> + <member values="XR_TYPE_SCENE_MESH_INDICES_UINT16_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCountOutput</name></member> + <member optional="true" len="indexCapacityInput"><type>uint16_t</type>* <name>indices</name></member> + </type> + + <!-- XR_MSFT_scene_understanding_serialization --> + <type category="struct" name="XrSerializedSceneFragmentDataGetInfoMSFT"> + <member values="XR_TYPE_SERIALIZED_SCENE_FRAGMENT_DATA_GET_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrUuidMSFT</type> <name>sceneFragmentId</name></member> + </type> + <type category="struct" name="XrDeserializeSceneFragmentMSFT"> + <member optional="true"><type>uint32_t</type> <name>bufferSize</name></member> + <member optional="true" len="bufferSize">const <type>uint8_t</type>* <name>buffer</name></member> + </type> + <type category="struct" name="XrSceneDeserializeInfoMSFT"> + <member values="XR_TYPE_SCENE_DESERIALIZE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>fragmentCount</name></member> + <member optional="true" len="fragmentCount">const <type>XrDeserializeSceneFragmentMSFT</type>* <name>fragments</name></member> + </type> + + <!-- XR_MSFT_scene_marker --> + <type name="XrSceneMarkerTypeMSFT" category="enum"/> + <type name="XrSceneMarkerQRCodeSymbolTypeMSFT" category="enum"/> + <type category="struct" name="XrSceneMarkerMSFT" returnedonly="true"> + <member><type>XrSceneMarkerTypeMSFT</type> <name>markerType</name></member> + <member><type>XrTime</type> <name>lastSeenTime</name></member> + <member><type>XrOffset2Df</type> <name>center</name></member> + <member><type>XrExtent2Df</type> <name>size</name></member> + </type> + <type category="struct" name="XrSceneMarkersMSFT" structextends="XrSceneComponentsMSFT"> + <member values="XR_TYPE_SCENE_MARKERS_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>sceneMarkerCapacityInput</name></member> + <member optional="true" len="sceneMarkerCapacityInput"><type>XrSceneMarkerMSFT</type>* <name>sceneMarkers</name></member> + </type> + <type category="struct" name="XrSceneMarkerTypeFilterMSFT" structextends="XrSceneComponentsGetInfoMSFT"> + <member values="XR_TYPE_SCENE_MARKER_TYPE_FILTER_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>markerTypeCount</name></member> + <member optional="true" len="markerTypeCount"><type>XrSceneMarkerTypeMSFT</type>* <name>markerTypes</name></member> + </type> + <type category="struct" name="XrSceneMarkerQRCodeMSFT" returnedonly="true"> + <member><type>XrSceneMarkerQRCodeSymbolTypeMSFT</type> <name>symbolType</name></member> + <member><type>uint8_t</type> <name>version</name></member> + </type> + <type category="struct" name="XrSceneMarkerQRCodesMSFT" structextends="XrSceneComponentsMSFT"> + <member values="XR_TYPE_SCENE_MARKER_QR_CODES_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>qrCodeCapacityInput</name></member> + <member optional="true" len="qrCodeCapacityInput"><type>XrSceneMarkerQRCodeMSFT</type>* <name>qrCodes</name></member> + </type> + + <!-- XR_FB_color_space structs --> + <type name="XrColorSpaceFB" category="enum"/> + <type category="struct" name="XrSystemColorSpacePropertiesFB" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_COLOR_SPACE_PROPERTIES_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrColorSpaceFB</type> <name>colorSpace</name></member> + </type> + + <!-- XR_FB_spatial_entity structs --> + <type category="struct" name="XrSystemSpatialEntityPropertiesFB" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_SPATIAL_ENTITY_PROPERTIES_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSpatialEntity</name></member> + </type> + <type category="struct" name="XrSpatialAnchorCreateInfoFB"> + <member values="XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrPosef</type> <name>poseInSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrSpaceComponentStatusSetInfoFB"> + <member values="XR_TYPE_SPACE_COMPONENT_STATUS_SET_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpaceComponentTypeFB</type> <name>componentType</name></member> + <member><type>XrBool32</type> <name>enabled</name></member> + <member><type>XrDuration</type> <name>timeout</name></member> + </type> + <type category="struct" name="XrSpaceComponentStatusFB" returnedonly="true"> + <member values="XR_TYPE_SPACE_COMPONENT_STATUS_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>enabled</name></member> + <member><type>XrBool32</type> <name>changePending</name></member> + </type> + <type category="struct" name="XrEventDataSpatialAnchorCreateCompleteFB" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPATIAL_ANCHOR_CREATE_COMPLETE_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + </type> + <type category="struct" name="XrEventDataSpaceSetStatusCompleteFB" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPACE_SET_STATUS_COMPLETE_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + <member><type>XrSpaceComponentTypeFB</type> <name>componentType</name></member> + <member><type>XrBool32</type> <name>enabled</name></member> + </type> + + <!-- XR_FB_foveation structs --> + <type category="struct" name="XrFoveationProfileCreateInfoFB"> + <member values="XR_TYPE_FOVEATION_PROFILE_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrSwapchainCreateInfoFoveationFB" structextends="XrSwapchainCreateInfo"> + <member values="XR_TYPE_SWAPCHAIN_CREATE_INFO_FOVEATION_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrSwapchainCreateFoveationFlagsFB</type> <name>flags</name></member> + </type> + <type category="struct" name="XrSwapchainStateFoveationFB" parentstruct="XrSwapchainStateBaseHeaderFB"> + <member values="XR_TYPE_SWAPCHAIN_STATE_FOVEATION_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrSwapchainStateFoveationFlagsFB</type> <name>flags</name></member> + <member><type>XrFoveationProfileFB</type> <name>profile</name></member> + </type> + + <!-- XR_FB_foveation_vulkan structs --> + <type category="struct" name="XrSwapchainImageFoveationVulkanFB" structextends="XrSwapchainImageVulkanKHR" returnedonly="true"> + <member values="XR_TYPE_SWAPCHAIN_IMAGE_FOVEATION_VULKAN_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>VkImage</type> <name>image</name></member> + <member><type>uint32_t</type> <name>width</name></member> + <member><type>uint32_t</type> <name>height</name></member> + </type> + + <!-- XR_FB_foveation_configuration structs --> + <type name="XrFoveationLevelFB" category="enum"/> + <type name="XrFoveationDynamicFB" category="enum"/> + <type category="struct" name="XrFoveationLevelProfileCreateInfoFB" structextends="XrFoveationProfileCreateInfoFB"> + <member values="XR_TYPE_FOVEATION_LEVEL_PROFILE_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrFoveationLevelFB</type> <name>level</name></member> + <member><type>float</type> <name>verticalOffset</name></member> + <member><type>XrFoveationDynamicFB</type> <name>dynamic</name></member> + </type> + + <!-- XR_META_foveation_eye_tracked structs --> + <type category="struct" name="XrFoveationEyeTrackedProfileCreateInfoMETA" structextends="XrFoveationLevelProfileCreateInfoFB"> + <member values="XR_TYPE_FOVEATION_EYE_TRACKED_PROFILE_CREATE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrFoveationEyeTrackedProfileCreateFlagsMETA</type> <name>flags</name></member> + </type> + <type category="struct" name="XrFoveationEyeTrackedStateMETA" returnedonly="true"> + <member values="XR_TYPE_FOVEATION_EYE_TRACKED_STATE_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrVector2f</type> <name>foveationCenter</name>[<enum>XR_FOVEATION_CENTER_SIZE_META</enum>]</member> + <member><type>XrFoveationEyeTrackedStateFlagsMETA</type> <name>flags</name></member> + </type> + <type category="struct" name="XrSystemFoveationEyeTrackedPropertiesMETA" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_FOVEATION_EYE_TRACKED_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsFoveationEyeTracked</name></member> + </type> + + <!-- XR_FB_hand_tracking_mesh structs --> + <type category="struct" name="XrVector4sFB"> + <member><type>int16_t</type> <name>x</name></member> + <member><type>int16_t</type> <name>y</name></member> + <member><type>int16_t</type> <name>z</name></member> + <member><type>int16_t</type> <name>w</name></member> + </type> + <type category="struct" name="XrHandTrackingMeshFB"> + <member values="XR_TYPE_HAND_TRACKING_MESH_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>jointCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>jointCountOutput</name></member> + <member optional="true" len="jointCapacityInput"><type>XrPosef</type>* <name>jointBindPoses</name></member> + <member optional="true" len="jointCapacityInput"><type>float</type>* <name>jointRadii</name></member> + <member optional="true" len="jointCapacityInput"><type>XrHandJointEXT</type>* <name>jointParents</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCountOutput</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector3f</type>* <name>vertexPositions</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector3f</type>* <name>vertexNormals</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector2f</type>* <name>vertexUVs</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector4sFB</type>* <name>vertexBlendIndices</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector4f</type>* <name>vertexBlendWeights</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCountOutput</name></member> + <member optional="true" len="indexCapacityInput"><type>int16_t</type>* <name>indices</name></member> + </type> + <type category="struct" name="XrHandTrackingScaleFB" returnedonly="true" structextends="XrHandJointLocationsEXT"> + <member values="XR_TYPE_HAND_TRACKING_SCALE_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>float</type> <name>sensorOutput</name></member> + <member><type>float</type> <name>currentOutput</name></member> + <member><type>XrBool32</type> <name>overrideHandScale</name></member> + <member optional="true"><type>float</type> <name>overrideValueInput</name></member> + </type> + + <!-- XR_FB_hand_tracking_aim structs --> + <type category="struct" name="XrHandTrackingAimStateFB" returnedonly="true" structextends="XrHandJointLocationsEXT"> + <member values="XR_TYPE_HAND_TRACKING_AIM_STATE_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrHandTrackingAimFlagsFB</type> <name>status</name></member> + <member><type>XrPosef</type> <name>aimPose</name></member> + <member><type>float</type> <name>pinchStrengthIndex</name></member> + <member><type>float</type> <name>pinchStrengthMiddle</name></member> + <member><type>float</type> <name>pinchStrengthRing</name></member> + <member><type>float</type> <name>pinchStrengthLittle</name></member> + </type> + + <!-- XR_FB_hand_tracking_capsules structs --> + <type category="struct" name="XrHandCapsuleFB" returnedonly="true"> + <member><type>XrVector3f</type> <name>points</name>[<enum>XR_HAND_TRACKING_CAPSULE_POINT_COUNT_FB</enum>]</member> + <member><type>float</type> <name>radius</name></member> + <member><type>XrHandJointEXT</type> <name>joint</name></member> + </type> + <type category="struct" name="XrHandTrackingCapsulesStateFB" returnedonly="true" structextends="XrHandJointLocationsEXT"> + <member values="XR_TYPE_HAND_TRACKING_CAPSULES_STATE_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrHandCapsuleFB</type> <name>capsules</name>[<enum>XR_HAND_TRACKING_CAPSULE_COUNT_FB</enum>]</member> + </type> + + <!-- XR_FB_render_model structs --> + <type category="struct" name="XrRenderModelPathInfoFB"> + <member values="XR_TYPE_RENDER_MODEL_PATH_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrPath</type> <name>path</name></member> + </type> + <type category="struct" name="XrRenderModelPropertiesFB"> + <member values="XR_TYPE_RENDER_MODEL_PROPERTIES_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>vendorId</name></member> + <member><type>char</type> <name>modelName</name>[<enum>XR_MAX_RENDER_MODEL_NAME_SIZE_FB</enum>]</member> + <member><type>XrRenderModelKeyFB</type> <name>modelKey</name></member> + <member><type>uint32_t</type> <name>modelVersion</name></member> + <member><type>XrRenderModelFlagsFB</type> <name>flags</name></member> + </type> + <type category="struct" name="XrRenderModelCapabilitiesRequestFB" structextends="XrRenderModelPropertiesFB"> + <member values="XR_TYPE_RENDER_MODEL_CAPABILITIES_REQUEST_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrRenderModelFlagsFB</type> <name>flags</name></member> + </type> + <type category="struct" name="XrRenderModelBufferFB"> + <member values="XR_TYPE_RENDER_MODEL_BUFFER_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>bufferCountOutput</name></member> + <member optional="true" len="bufferCapacityInput"><type>uint8_t</type>* <name>buffer</name></member> + </type> + <type category="struct" name="XrRenderModelLoadInfoFB"> + <member values="XR_TYPE_RENDER_MODEL_LOAD_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrRenderModelKeyFB</type> <name>modelKey</name></member> + </type> + <type category="struct" name="XrSystemRenderModelPropertiesFB" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_RENDER_MODEL_PROPERTIES_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsRenderModelLoading</name></member> + </type> + + <!-- XR_FB_spatial_entity_query structs --> + <type category="struct" name="XrSpaceQueryInfoBaseHeaderFB"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrSpaceFilterInfoBaseHeaderFB"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrSpaceQueryInfoFB" parentstruct="XrSpaceQueryInfoBaseHeaderFB"> + <member values="XR_TYPE_SPACE_QUERY_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpaceQueryActionFB</type> <name>queryAction</name></member> + <member><type>uint32_t</type> <name>maxResultCount</name></member> + <member><type>XrDuration</type> <name>timeout</name></member> + <member optional="true">const <type>XrSpaceFilterInfoBaseHeaderFB</type>* <name>filter</name></member> + <member optional="true">const <type>XrSpaceFilterInfoBaseHeaderFB</type>* <name>excludeFilter</name></member> + </type> + <type category="struct" name="XrSpaceStorageLocationFilterInfoFB" structextends="XrSpaceFilterInfoBaseHeaderFB"> + <member values="XR_TYPE_SPACE_STORAGE_LOCATION_FILTER_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpaceStorageLocationFB</type> <name>location</name></member> + </type> + <type category="struct" name="XrSpaceUuidFilterInfoFB" parentstruct="XrSpaceFilterInfoBaseHeaderFB"> + <member values="XR_TYPE_SPACE_UUID_FILTER_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>uuidCount</name></member> + <member len="uuidCount"><type>XrUuidEXT</type>* <name>uuids</name></member> + </type> + <type category="struct" name="XrSpaceComponentFilterInfoFB" parentstruct="XrSpaceFilterInfoBaseHeaderFB"> + <member values="XR_TYPE_SPACE_COMPONENT_FILTER_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpaceComponentTypeFB</type> <name>componentType</name></member> + </type> + <type category="struct" name="XrSpaceQueryResultFB" returnedonly="true"> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + </type> + <type category="struct" name="XrSpaceQueryResultsFB"> + <member values="XR_TYPE_SPACE_QUERY_RESULTS_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>resultCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>resultCountOutput</name></member> + <member optional="true" len="resultCapacityInput"><type>XrSpaceQueryResultFB</type>* <name>results</name></member> + </type> + <type category="struct" name="XrEventDataSpaceQueryResultsAvailableFB" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPACE_QUERY_RESULTS_AVAILABLE_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + </type> + <type category="struct" name="XrEventDataSpaceQueryCompleteFB" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPACE_QUERY_COMPLETE_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + + <!-- XR_FB_spatial_entity_storage structs --> + <type category="struct" name="XrSpaceSaveInfoFB"> + <member values="XR_TYPE_SPACE_SAVE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrSpaceStorageLocationFB</type> <name>location</name></member> + <member><type>XrSpacePersistenceModeFB</type> <name>persistenceMode</name></member> + </type> + <type category="struct" name="XrSpaceEraseInfoFB"> + <member values="XR_TYPE_SPACE_ERASE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrSpaceStorageLocationFB</type> <name>location</name></member> + </type> + <type category="struct" name="XrEventDataSpaceSaveCompleteFB" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPACE_SAVE_COMPLETE_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + <member><type>XrSpaceStorageLocationFB</type> <name>location</name></member> + </type> + <type category="struct" name="XrEventDataSpaceEraseCompleteFB" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPACE_ERASE_COMPLETE_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + <member><type>XrSpaceStorageLocationFB</type> <name>location</name></member> + </type> + + <!-- XR_FB_spatial_entity_sharing structs --> + <type category="struct" name="XrSpaceShareInfoFB"> + <member values="XR_TYPE_SPACE_SHARE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>spaceCount</name></member> + <member len="spaceCount"><type>XrSpace</type>* <name>spaces</name></member> + <member><type>uint32_t</type> <name>userCount</name></member> + <member len="userCount"><type>XrSpaceUserFB</type>* <name>users</name></member> + </type> + <type category="struct" name="XrEventDataSpaceShareCompleteFB" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPACE_SHARE_COMPLETE_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + + <!-- XR_FB_spatial_entity_storage_batch structs --> + <type category="struct" name="XrSpaceListSaveInfoFB"> + <member values="XR_TYPE_SPACE_LIST_SAVE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>spaceCount</name></member> + <member len="spaceCount"><type>XrSpace</type>* <name>spaces</name></member> + <member><type>XrSpaceStorageLocationFB</type> <name>location</name></member> + </type> + <type category="struct" name="XrEventDataSpaceListSaveCompleteFB" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPACE_LIST_SAVE_COMPLETE_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + + <!-- XR_FB_spatial_entity_container structs --> + <type category="struct" name="XrSpaceContainerFB"> + <member values="XR_TYPE_SPACE_CONTAINER_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>uuidCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>uuidCountOutput</name></member> + <member optional="true" len="uuidCapacityInput"><type>XrUuidEXT</type>* <name>uuids</name></member> + </type> + + <!-- XR_META_spatial_entity_mesh structs --> + <type category="struct" name="XrSpaceTriangleMeshGetInfoMETA"> + <member values="XR_TYPE_SPACE_TRIANGLE_MESH_GET_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrSpaceTriangleMeshMETA" returnedonly="true"> + <member values="XR_TYPE_SPACE_TRIANGLE_MESH_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCountOutput</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector3f</type>* <name>vertices</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCountOutput</name></member> + <member optional="true" len="indexCapacityInput"><type>uint32_t</type>* <name>indices</name></member> + </type> + + <!-- XR_META_spatial_entity_room_mesh structs --> + <type category="struct" name="XrRoomMeshFaceMETA"> + <member><type>XrUuid</type> <name>uuid</name></member> + <member optional="true"><type>XrUuid</type> <name>parentUuid</name></member> + <member><type>XrSemanticLabelMETA</type> <name>semanticLabel</name></member> + </type> + + <type category="struct" name="XrRoomMeshFaceIndicesMETA"> + <member values="XR_TYPE_ROOM_MESH_FACE_INDICES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCountOutput</name></member> + <member optional="true" len="indexCapacityInput"><type>uint32_t</type>* <name>indices</name></member> + </type> + + <type category="struct" name="XrSpaceRoomMeshGetInfoMETA"> + <member values="XR_TYPE_SPACE_ROOM_MESH_GET_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>recognizedSemanticLabelCount</name></member> + <member optional="true" len="recognizedSemanticLabelCount">const <type>XrSemanticLabelMETA</type>* <name>recognizedSemanticLabels</name></member> + </type> + + <type category="struct" name="XrRoomMeshMETA"> + <member values="XR_TYPE_ROOM_MESH_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCountOutput</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector3f</type>* <name>vertices</name></member> + <member optional="true"><type>uint32_t</type> <name>faceCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>faceCountOutput</name></member> + <member optional="true" len="faceCapacityInput"><type>XrRoomMeshFaceMETA</type>* <name>faces</name></member> + </type> + + <!-- XR_META_boundary_visibility structs --> + <type category="struct" name="XrSystemBoundaryVisibilityPropertiesMETA" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_BOUNDARY_VISIBILITY_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsBoundaryVisibility</name></member> + </type> + + <type category="struct" name="XrEventDataBoundaryVisibilityChangedMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_BOUNDARY_VISIBILITY_CHANGED_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBoundaryVisibilityMETA</type> <name>boundaryVisibility</name></member> + </type> + + <!-- XR_FB_scene structs --> + <type category="struct" name="XrExtent3DfFB" alias="XrExtent3Df"/> + + <type category="struct" name="XrOffset3DfFB"> + <member><type>float</type> <name>x</name></member> + <member><type>float</type> <name>y</name></member> + <member><type>float</type> <name>z</name></member> + </type> + + <type category="struct" name="XrRect3DfFB"> + <member><type>XrOffset3DfFB</type> <name>offset</name></member> + <member><type>XrExtent3DfFB</type> <name>extent</name></member> + </type> + + <type category="struct" name="XrSemanticLabelsFB"> + <member values="XR_TYPE_SEMANTIC_LABELS_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>bufferCountOutput</name></member> + <member optional="true" len="bufferCapacityInput"><type>char</type>* <name>buffer</name></member> + </type> + <type category="struct" name="XrRoomLayoutFB"> + <member values="XR_TYPE_ROOM_LAYOUT_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrUuidEXT</type> <name>floorUuid</name></member> + <member><type>XrUuidEXT</type> <name>ceilingUuid</name></member> + <member optional="true"><type>uint32_t</type> <name>wallUuidCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>wallUuidCountOutput</name></member> + <member optional="true" len="wallUuidCapacityInput"><type>XrUuidEXT</type>* <name>wallUuids</name></member> + </type> + <type category="struct" name="XrBoundary2DFB"> + <member values="XR_TYPE_BOUNDARY_2D_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCountOutput</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector2f</type>* <name>vertices</name></member> + </type> + <type category="struct" name="XrSemanticLabelsSupportInfoFB" structextends="XrSemanticLabelsFB"> + <member values="XR_TYPE_SEMANTIC_LABELS_SUPPORT_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrSemanticLabelsSupportFlagsFB</type> <name>flags</name></member> + <member len="null-terminated">const <type>char</type>* <name>recognizedLabels</name></member> + </type> + + <!-- XR_FB_scene_capture structs --> + <type category="struct" name="XrSceneCaptureRequestInfoFB"> + <member values="XR_TYPE_SCENE_CAPTURE_REQUEST_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>requestByteCount</name></member> + <member optional="true" len="requestByteCount">const <type>char</type>* <name>request</name></member> + </type> + <type category="struct" name="XrEventDataSceneCaptureCompleteFB" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SCENE_CAPTURE_COMPLETE_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + + <!-- XR_FB_keyboard_tracking structs --> + <type category="struct" name="XrSystemKeyboardTrackingPropertiesFB" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_KEYBOARD_TRACKING_PROPERTIES_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsKeyboardTracking</name></member> + </type> + <type category="struct" name="XrKeyboardTrackingDescriptionFB" returnedonly="true"> + <member><type>uint64_t</type> <name>trackedKeyboardId</name></member> + <member><type>XrVector3f</type> <name>size</name></member> + <member><type>XrKeyboardTrackingFlagsFB</type> <name>flags</name></member> + <member><type>char</type> <name>name</name>[<enum>XR_MAX_KEYBOARD_TRACKING_NAME_SIZE_FB</enum>]</member> + </type> + <type category="struct" name="XrKeyboardSpaceCreateInfoFB"> + <member values="XR_TYPE_KEYBOARD_SPACE_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint64_t</type> <name>trackedKeyboardId</name></member> + </type> + <type category="struct" name="XrKeyboardTrackingQueryFB"> + <member values="XR_TYPE_KEYBOARD_TRACKING_QUERY_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrKeyboardTrackingQueryFlagsFB</type> <name>flags</name></member> + </type> + + <!-- XR_META_colocation_discovery --> + <type category="struct" name="XrSystemColocationDiscoveryPropertiesMETA" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_COLOCATION_DISCOVERY_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsColocationDiscovery</name></member> + </type> + <type category="struct" name="XrColocationAdvertisementStartInfoMETA"> + <member values="XR_TYPE_COLOCATION_ADVERTISEMENT_START_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>bufferSize</name></member> + <member len="bufferSize"><type>uint8_t</type>* <name>buffer</name></member> + </type> + <type category="struct" name="XrColocationAdvertisementStopInfoMETA"> + <member values="XR_TYPE_COLOCATION_ADVERTISEMENT_STOP_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrColocationDiscoveryStartInfoMETA"> + <member values="XR_TYPE_COLOCATION_DISCOVERY_START_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrColocationDiscoveryStopInfoMETA"> + <member values="XR_TYPE_COLOCATION_DISCOVERY_STOP_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrEventDataStartColocationAdvertisementCompleteMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_START_COLOCATION_ADVERTISEMENT_COMPLETE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>advertisementRequestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + <member><type>XrUuid</type> <name>advertisementUuid</name></member> + </type> + <type category="struct" name="XrEventDataColocationAdvertisementCompleteMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_COLOCATION_ADVERTISEMENT_COMPLETE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>advertisementRequestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + <type category="struct" name="XrEventDataStopColocationAdvertisementCompleteMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_STOP_COLOCATION_ADVERTISEMENT_COMPLETE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + <type category="struct" name="XrEventDataStartColocationDiscoveryCompleteMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_START_COLOCATION_DISCOVERY_COMPLETE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>discoveryRequestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + <type category="struct" name="XrEventDataColocationDiscoveryResultMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_COLOCATION_DISCOVERY_RESULT_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>discoveryRequestId</name></member> + <member><type>XrUuid</type> <name>advertisementUuid</name></member> + <member><type>uint32_t</type> <name>bufferSize</name></member> + <member len="bufferSize"><type>uint8_t</type> <name>buffer</name>[<enum>XR_MAX_COLOCATION_DISCOVERY_BUFFER_SIZE_META</enum>]</member> + </type> + <type category="struct" name="XrEventDataColocationDiscoveryCompleteMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_COLOCATION_DISCOVERY_COMPLETE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>discoveryRequestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + <type category="struct" name="XrEventDataStopColocationDiscoveryCompleteMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_STOP_COLOCATION_DISCOVERY_COMPLETE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + + <!-- XR_META_spatial_entity_sharing --> + <type category="struct" name="XrSystemSpatialEntitySharingPropertiesMETA" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_SPATIAL_ENTITY_SHARING_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSpatialEntitySharing</name></member> + </type> + <type category="struct" name="XrShareSpacesRecipientBaseHeaderMETA"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrShareSpacesInfoMETA"> + <member values="XR_TYPE_SHARE_SPACES_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>spaceCount</name></member> + <member len="spaceCount"><type>XrSpace</type>* <name>spaces</name></member> + <member>const <type>XrShareSpacesRecipientBaseHeaderMETA</type>* <name>recipientInfo</name></member> + </type> + <type category="struct" name="XrEventDataShareSpacesCompleteMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SHARE_SPACES_COMPLETE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + + <!-- XR_META_spatial_entity_group_sharing --> + <type category="struct" name="XrShareSpacesRecipientGroupsMETA" parentstruct="XrShareSpacesRecipientBaseHeaderMETA"> + <member values="XR_TYPE_SHARE_SPACES_RECIPIENT_GROUPS_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>groupCount</name></member> + <member len="groupCount"><type>XrUuid</type>* <name>groups</name></member> + </type> + <type category="struct" name="XrSpaceGroupUuidFilterInfoMETA" structextends="XrSpaceQueryInfoBaseHeaderFB"> + <member values="XR_TYPE_SPACE_GROUP_UUID_FILTER_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrUuid</type> <name>groupUuid</name></member> + </type> + <type category="struct" name="XrSystemSpatialEntityGroupSharingPropertiesMETA" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_SPATIAL_ENTITY_GROUP_SHARING_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSpatialEntityGroupSharing</name></member> + </type> + + <!-- XR_VARJO_composition_layer_depth_test --> + <type category="struct" name="XrCompositionLayerDepthTestVARJO" structextends="XrCompositionLayerProjection"> + <member values="XR_TYPE_COMPOSITION_LAYER_DEPTH_TEST_VARJO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>depthTestRangeNearZ</name></member> + <member><type>float</type> <name>depthTestRangeFarZ</name></member> + </type> + + <!-- XR_VARJO_foveated_rendering --> + <type category="struct" name="XrViewLocateFoveatedRenderingVARJO" structextends="XrViewLocateInfo"> + <member values="XR_TYPE_VIEW_LOCATE_FOVEATED_RENDERING_VARJO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>foveatedRenderingActive</name></member> + </type> + + <type category="struct" name="XrFoveatedViewConfigurationViewVARJO" structextends="XrViewConfigurationView"> + <member values="XR_TYPE_FOVEATED_VIEW_CONFIGURATION_VIEW_VARJO"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>foveatedRenderingActive</name></member> + </type> + + <type category="struct" name="XrSystemFoveatedRenderingPropertiesVARJO" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_FOVEATED_RENDERING_PROPERTIES_VARJO"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsFoveatedRendering</name></member> + </type> + + <!-- XR_MSFT_composition_layer_reprojection --> + <type name="XrReprojectionModeMSFT" category="enum"/> + <type category="struct" name="XrCompositionLayerReprojectionInfoMSFT" structextends="XrCompositionLayerProjection"> + <member values="XR_TYPE_COMPOSITION_LAYER_REPROJECTION_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrReprojectionModeMSFT</type> <name>reprojectionMode</name></member> + </type> + <type category="struct" name="XrCompositionLayerReprojectionPlaneOverrideMSFT" structextends="XrCompositionLayerProjection"> + <member values="XR_TYPE_COMPOSITION_LAYER_REPROJECTION_PLANE_OVERRIDE_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrVector3f</type> <name>position</name></member> + <member><type>XrVector3f</type> <name>normal</name></member> + <member><type>XrVector3f</type> <name>velocity</name></member> + </type> + + <!-- XR_FB_triangle_mesh --> + <type category="struct" name="XrTriangleMeshCreateInfoFB"> + <member values="XR_TYPE_TRIANGLE_MESH_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrTriangleMeshFlagsFB</type> <name>flags</name></member> + <member><type>XrWindingOrderFB</type> <name>windingOrder</name></member> + <member><type>uint32_t</type> <name>vertexCount</name></member> + <member optional="true" noautovalidity="true">const <type>XrVector3f</type>* <name>vertexBuffer</name></member> + <member><type>uint32_t</type> <name>triangleCount</name></member> + <member optional="true" noautovalidity="true">const <type>uint32_t</type>* <name>indexBuffer</name></member> + </type> + + <!-- XR_FB_passthrough --> + <type category="struct" name="XrSystemPassthroughPropertiesFB" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_PASSTHROUGH_PROPERTIES_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsPassthrough</name></member> + </type> + <type category="struct" name="XrSystemPassthroughProperties2FB" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_PASSTHROUGH_PROPERTIES2_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrPassthroughCapabilityFlagsFB</type> <name>capabilities</name></member> + </type> + <type category="struct" name="XrPassthroughCreateInfoFB"> + <member values="XR_TYPE_PASSTHROUGH_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrPassthroughFlagsFB</type> <name>flags</name></member> + </type> + <type category="struct" name="XrPassthroughLayerCreateInfoFB"> + <member values="XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPassthroughFB</type> <name>passthrough</name></member> + <member optional="true"><type>XrPassthroughFlagsFB</type> <name>flags</name></member> + <member><type>XrPassthroughLayerPurposeFB</type> <name>purpose</name></member> + </type> + <type category="struct" name="XrCompositionLayerPassthroughFB" parentstruct="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCompositionLayerFlags</type> <name>flags</name></member> + <member optional="true"><type>XrSpace</type> <name>space</name></member> + <member><type>XrPassthroughLayerFB</type> <name>layerHandle</name></member> + </type> + <type category="struct" name="XrGeometryInstanceCreateInfoFB"> + <member values="XR_TYPE_GEOMETRY_INSTANCE_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPassthroughLayerFB</type> <name>layer</name></member> + <member><type>XrTriangleMeshFB</type> <name>mesh</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrVector3f</type> <name>scale</name></member> + </type> + <type category="struct" name="XrGeometryInstanceTransformFB"> + <member values="XR_TYPE_GEOMETRY_INSTANCE_TRANSFORM_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrVector3f</type> <name>scale</name></member> + </type> + <type category="struct" name="XrPassthroughStyleFB"> + <member values="XR_TYPE_PASSTHROUGH_STYLE_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>textureOpacityFactor</name></member> + <member><type>XrColor4f</type> <name>edgeColor</name></member> + </type> + <type category="struct" name="XrPassthroughColorMapMonoToRgbaFB" structextends="XrPassthroughStyleFB"> + <member values="XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_RGBA_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrColor4f</type> <name>textureColorMap</name>[<enum>XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB</enum>]</member> + </type> + <type category="struct" name="XrPassthroughColorMapMonoToMonoFB" structextends="XrPassthroughStyleFB"> + <member values="XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_MONO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint8_t</type> <name>textureColorMap</name>[<enum>XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB</enum>]</member> + </type> + <type category="struct" name="XrPassthroughBrightnessContrastSaturationFB" structextends="XrPassthroughStyleFB"> + <member values="XR_TYPE_PASSTHROUGH_BRIGHTNESS_CONTRAST_SATURATION_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>brightness</name></member> + <member><type>float</type> <name>contrast</name></member> + <member><type>float</type> <name>saturation</name></member> + </type> + <type category="struct" name="XrEventDataPassthroughStateChangedFB" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_PASSTHROUGH_STATE_CHANGED_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPassthroughStateChangedFlagsFB</type> <name>flags</name></member> + </type> + + <!-- XR_FB_passthrough_keyboard_hands --> + <type category="struct" name="XrPassthroughKeyboardHandsIntensityFB"> + <member values="XR_TYPE_PASSTHROUGH_KEYBOARD_HANDS_INTENSITY_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>leftHandIntensity</name></member> + <member><type>float</type> <name>rightHandIntensity</name></member> + </type> + + <!-- XR_META_local_dimming --> + <type category="struct" name="XrLocalDimmingFrameEndInfoMETA" structextends="XrFrameEndInfo"> + <member values="XR_TYPE_LOCAL_DIMMING_FRAME_END_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrLocalDimmingModeMETA</type> <name>localDimmingMode</name></member> + </type> + + <!-- XR_MSFT_spatial_anchor_persistence --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSpatialAnchorStoreConnectionMSFT</name>)</type> + + <type category="struct" name="XrSpatialAnchorPersistenceNameMSFT"> + <member><type>char</type> <name>name</name>[<enum>XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_MSFT</enum>]</member> + </type> + <type category="struct" name="XrSpatialAnchorPersistenceInfoMSFT"> + <member values="XR_TYPE_SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialAnchorPersistenceNameMSFT</type> <name>spatialAnchorPersistenceName</name></member> + <member><type>XrSpatialAnchorMSFT</type> <name>spatialAnchor</name></member> + </type> + <type category="struct" name="XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT"> + <member values="XR_TYPE_SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_INFO_MSFT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialAnchorStoreConnectionMSFT</type> <name>spatialAnchorStore</name></member> + <member><type>XrSpatialAnchorPersistenceNameMSFT</type> <name>spatialAnchorPersistenceName</name></member> + </type> + + <!-- XR_BD_body_tracking --> + <type category="struct" name="XrSystemBodyTrackingPropertiesBD" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsBodyTracking</name></member> + </type> + <type category="struct" name="XrBodyTrackerCreateInfoBD"> + <member values="XR_TYPE_BODY_TRACKER_CREATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBodyJointSetBD</type> <name>jointSet</name></member> + </type> + <type category="struct" name="XrBodyJointsLocateInfoBD"> + <member values="XR_TYPE_BODY_JOINTS_LOCATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrBodyJointLocationBD"> + <member optional="true"><type>XrSpaceLocationFlags</type> <name>locationFlags</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrBodyJointLocationsBD"> + <member values="XR_TYPE_BODY_JOINT_LOCATIONS_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>allJointPosesTracked</name></member> + <member><type>uint32_t</type> <name>jointLocationCount</name></member> + <member len="jointLocationCount"><type>XrBodyJointLocationBD</type>* <name>jointLocations</name></member> + </type> + + <!-- XR_BD_future_progress --> + <type category="struct" name="XrFuturePollResultProgressBD" structextends="XrFuturePollResultEXT" returnedonly="true"> + <member values="XR_TYPE_FUTURE_POLL_RESULT_PROGRESS_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>isSupported</name></member> + <member><type>uint32_t</type> <name>progressPercentage</name></member> + </type> + + <!-- XR_BD_body_tracking_auxiliary_metrics --> + <type category="struct" name="XrBodyTrackingPostureDataBD" structextends="XrBodyJointLocationsBD"> + <member values="XR_TYPE_BODY_TRACKING_POSTURE_DATA_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>postureCount</name></member> + <member len="postureCount"><type>XrBodyTrackingPostureBD</type>* <name>postureData</name></member> + </type> + <type category="struct" name="XrBodyJointVelocityBD"> + <member optional="true"><type>XrSpaceVelocityFlags</type> <name>velocityFlags</name></member> + <member><type>XrVector3f</type> <name>linearVelocity</name></member> + <member><type>XrVector3f</type> <name>angularVelocity</name></member> + </type> + <type category="struct" name="XrBodyJointVelocitiesBD" structextends="XrBodyJointLocationsBD"> + <member values="XR_TYPE_BODY_JOINT_VELOCITIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>velocityCount</name></member> + <member len="velocityCount"><type>XrBodyJointVelocityBD</type>* <name>velocities</name></member> + </type> + <type category="struct" name="XrBodyJointAccelerationBD"> + <member optional="true"><type>XrSpaceAccelerationFlagsBD</type> <name>accelerationFlags</name></member> + <member><type>XrVector3f</type> <name>linearAcceleration</name></member> + <member><type>XrVector3f</type> <name>angularAcceleration</name></member> + </type> + <type category="struct" name="XrBodyJointAccelerationsBD" structextends="XrBodyJointLocationsBD"> + <member values="XR_TYPE_BODY_JOINT_ACCELERATIONS_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>accelerationCount</name></member> + <member len="accelerationCount"><type>XrBodyJointAccelerationBD</type>* <name>accelerations</name></member> + </type> + <type category="struct" name="XrBodyTrackingStateBD"> + <member values="XR_TYPE_BODY_TRACKING_STATE_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBodyTrackingStatusBD</type> <name>status</name></member> + <member><type>XrBodyTrackingMessageBD</type> <name>message</name></member> + </type> + + <!-- XR_HTC_facial_tracking --> + <type category="struct" name="XrFacialTrackerCreateInfoHTC"> + <member values="XR_TYPE_FACIAL_TRACKER_CREATE_INFO_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrFacialTrackingTypeHTC</type> <name>facialTrackingType</name></member> + </type> + <type category="struct" name="XrSystemFacialTrackingPropertiesHTC" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_FACIAL_TRACKING_PROPERTIES_HTC"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportEyeFacialTracking</name></member> + <member><type>XrBool32</type> <name>supportLipFacialTracking</name></member> + </type> + <type category="struct" name="XrFacialExpressionsHTC"> + <member values="XR_TYPE_FACIAL_EXPRESSIONS_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>isActive</name></member> + <member><type>XrTime</type> <name>sampleTime</name></member> + <member><type>uint32_t</type> <name>expressionCount</name></member> + <member><type>float</type>* <name>expressionWeightings</name></member> + </type> + + <!-- XR_HTC_passthrough --> + <type category="struct" name="XrPassthroughCreateInfoHTC"> + <member values="XR_TYPE_PASSTHROUGH_CREATE_INFO_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPassthroughFormHTC</type> <name>form</name></member> + </type> + <type category="struct" name="XrPassthroughColorHTC"> + <member values="XR_TYPE_PASSTHROUGH_COLOR_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>alpha</name></member> + </type> + <type category="struct" name="XrPassthroughMeshTransformInfoHTC" structextends="XrCompositionLayerPassthroughHTC"> + <member values="XR_TYPE_PASSTHROUGH_MESH_TRANSFORM_INFO_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>vertexCount</name></member> + <member len="vertexCount">const <type>XrVector3f</type>* <name>vertices</name></member> + <member><type>uint32_t</type> <name>indexCount</name></member> + <member len="indexCount">const <type>uint32_t</type>* <name>indices</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrVector3f</type> <name>scale</name></member> + </type> + <type category="struct" name="XrCompositionLayerPassthroughHTC" parentstruct="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCompositionLayerFlags</type> <name>layerFlags</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrPassthroughHTC</type> <name>passthrough</name></member> + <member><type>XrPassthroughColorHTC</type> <name>color</name></member> + </type> + + <!-- XR_HTC_anchor --> + <type category="struct" name="XrSpatialAnchorCreateInfoHTC"> + <member values="XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrPosef</type> <name>poseInSpace</name></member> + <member><type>XrSpatialAnchorNameHTC</type> <name>name</name></member> + </type> + <type category="struct" name="XrSpatialAnchorNameHTC"> + <member><type>char</type> <name>name</name>[<enum>XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_HTC</enum>]</member> + </type> + <type category="struct" name="XrSystemAnchorPropertiesHTC" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_ANCHOR_PROPERTIES_HTC"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsAnchor</name></member> + </type> + + <!-- XR_HTCX_vive_tracker_interaction structs --> + <type category="struct" name="XrViveTrackerPathsHTCX" returnedonly="true"> + <member values="XR_TYPE_VIVE_TRACKER_PATHS_HTCX"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrPath</type> <name>persistentPath</name></member> + <member optional="true"><type>XrPath</type> <name>rolePath</name></member> + </type> + <type category="struct" name="XrEventDataViveTrackerConnectedHTCX" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_VIVE_TRACKER_CONNECTED_HTCX"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrViveTrackerPathsHTCX</type>* <name>paths</name></member> + </type> + + <!-- XR_HTC_body_tracking --> + <type category="struct" name="XrSystemBodyTrackingPropertiesHTC" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_HTC"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsBodyTracking</name></member> + </type> + <type category="struct" name="XrBodyTrackerCreateInfoHTC"> + <member values="XR_TYPE_BODY_TRACKER_CREATE_INFO_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBodyJointSetHTC</type> <name>bodyJointSet</name></member> + </type> + <type category="struct" name="XrBodySkeletonJointHTC"> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrBodySkeletonHTC"> + <member values="XR_TYPE_BODY_SKELETON_HTC"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>jointCount</name></member> + <member len="jointCount"><type>XrBodySkeletonJointHTC</type>* <name>joints</name></member> + </type> + <type category="struct" name="XrBodyJointsLocateInfoHTC"> + <member values="XR_TYPE_BODY_JOINTS_LOCATE_INFO_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrBodyJointLocationHTC" returnedonly="true"> + <member optional="true"><type>XrSpaceLocationFlags</type> <name>locationFlags</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrBodyJointLocationsHTC"> + <member values="XR_TYPE_BODY_JOINT_LOCATIONS_HTC"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrSpaceLocationFlags</type> <name>combinedLocationFlags</name></member> + <member><type>XrBodyJointConfidenceHTC</type> <name>confidenceLevel</name></member> + <member><type>uint32_t</type> <name>jointLocationCount</name></member> + <member len="jointLocationCount"><type>XrBodyJointLocationHTC</type>* <name>jointLocations</name></member> + <member><type>uint32_t</type> <name>skeletonGenerationId</name></member> + </type> + + <!-- XR_FB_space_warp --> + <type category="struct" name="XrCompositionLayerSpaceWarpInfoFB" structextends="XrCompositionLayerProjectionView"> + <member values="XR_TYPE_COMPOSITION_LAYER_SPACE_WARP_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrCompositionLayerSpaceWarpInfoFlagsFB</type> <name>layerFlags</name></member> + <member><type>XrSwapchainSubImage</type> <name>motionVectorSubImage</name></member> + <member><type>XrPosef</type> <name>appSpaceDeltaPose</name></member> + <member><type>XrSwapchainSubImage</type> <name>depthSubImage</name></member> + <member><type>float</type> <name>minDepth</name></member> + <member><type>float</type> <name>maxDepth</name></member> + <member><type>float</type> <name>nearZ</name></member> + <member><type>float</type> <name>farZ</name></member> + </type> + <type category="struct" name="XrSystemSpaceWarpPropertiesFB" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_SPACE_WARP_PROPERTIES_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>recommendedMotionVectorImageRectWidth</name></member> + <member><type>uint32_t</type> <name>recommendedMotionVectorImageRectHeight</name></member> + </type> + + + <!-- XR_VARJO_marker_tracking --> + <type category="struct" name="XrSystemMarkerTrackingPropertiesVARJO" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_VARJO"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsMarkerTracking</name></member> + </type> + + <type category="struct" name="XrEventDataMarkerTrackingUpdateVARJO" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_MARKER_TRACKING_UPDATE_VARJO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint64_t</type> <name>markerId</name></member> + <member><type>XrBool32</type> <name>isActive</name></member> + <member><type>XrBool32</type> <name>isPredicted</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <type category="struct" name="XrMarkerSpaceCreateInfoVARJO"> + <member values="XR_TYPE_MARKER_SPACE_CREATE_INFO_VARJO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint64_t</type> <name>markerId</name></member> + <member><type>XrPosef</type> <name>poseInMarkerSpace</name></member> + </type> + + <!-- XR_EXT_uuid --> + <type category="struct" name="XrUuidEXT" alias="XrUuid"/> + + <!-- XR_ML_global_dimmer --> + <type category="struct" name="XrGlobalDimmerFrameEndInfoML" structextends="XrFrameEndInfo"> + <member values="XR_TYPE_GLOBAL_DIMMER_FRAME_END_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>dimmerValue</name></member> + <member optional="true"><type>XrGlobalDimmerFrameEndInfoFlagsML</type> <name>flags</name></member> + </type> + + <!-- XR_ALMALENCE_digital_lens_control --> + <type category="struct" name="XrDigitalLensControlALMALENCE"> + <member values="XR_TYPE_DIGITAL_LENS_CONTROL_ALMALENCE"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrDigitalLensControlFlagsALMALENCE</type> <name>flags</name></member> + </type> + + <!-- XR_ULTRALEAP_hand_tracking_forearm --> + <type name="XrHandForearmJointULTRALEAP" category="enum"/> + + <!-- XR_FB_composition_layer_depth_test --> + <type name="XrCompareOpFB" category="enum"/> + + <!-- XR_FB_composition_layer_settings structs --> + <type category="struct" name="XrCompositionLayerSettingsFB" structextends="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_SETTINGS_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCompositionLayerSettingsFlagsFB</type> <name>layerFlags</name></member> + </type> + + <!-- XR_OCULUS_external_camera --> + <type category="struct" name="XrExternalCameraIntrinsicsOCULUS"> + <member><type>XrTime</type> <name>lastChangeTime</name></member> + <member><type>XrFovf</type> <name>fov</name></member> + <member><type>float</type> <name>virtualNearPlaneDistance</name></member> + <member><type>float</type> <name>virtualFarPlaneDistance</name></member> + <member><type>XrExtent2Di</type> <name>imageSensorPixelResolution</name></member> + </type> + + <type category="struct" name="XrExternalCameraExtrinsicsOCULUS"> + <member><type>XrTime</type> <name>lastChangeTime</name></member> + <member optional="true"><type>XrExternalCameraStatusFlagsOCULUS</type> <name>cameraStatusFlags</name></member> + <member><type>XrExternalCameraAttachedToDeviceOCULUS</type> <name>attachedToDevice</name></member> + <member><type>XrPosef</type> <name>relativePose</name></member> + </type> + + <type category="struct" name="XrExternalCameraOCULUS" returnedonly="true"> + <member values="XR_TYPE_EXTERNAL_CAMERA_OCULUS"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>char</type> <name>name</name>[<enum>XR_MAX_EXTERNAL_CAMERA_NAME_SIZE_OCULUS</enum>]</member> + <member><type>XrExternalCameraIntrinsicsOCULUS</type> <name>intrinsics</name></member> + <member><type>XrExternalCameraExtrinsicsOCULUS</type> <name>extrinsics</name></member> + </type> + + <!-- XR_META_performance_metrics --> + <type category="struct" name="XrPerformanceMetricsStateMETA"> + <member values="XR_TYPE_PERFORMANCE_METRICS_STATE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>enabled</name></member> + </type> + + <type category="struct" name="XrPerformanceMetricsCounterMETA"> + <member values="XR_TYPE_PERFORMANCE_METRICS_COUNTER_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrPerformanceMetricsCounterFlagsMETA</type> <name>counterFlags</name></member> + <member><type>XrPerformanceMetricsCounterUnitMETA</type> <name>counterUnit</name></member> + <member><type>uint32_t</type> <name>uintValue</name></member> + <member><type>float</type> <name>floatValue</name></member> + </type> + + <!-- XR_META_passthrough_preferences structs --> + <type category="struct" name="XrPassthroughPreferencesMETA" returnedonly="true"> + <member values="XR_TYPE_PASSTHROUGH_PREFERENCES_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPassthroughPreferenceFlagsMETA</type> <name>flags</name></member> + </type> + + <!-- XR_META_headset_id structs --> + <type category="struct" name="XrSystemHeadsetIdPropertiesMETA" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_HEADSET_ID_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrUuidEXT</type> <name>id</name></member> + </type> + + <!-- XR_META_spatial_entity_persistence structs --> + <type category="struct" name="XrSystemSpacePersistencePropertiesMETA" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_SPACE_PERSISTENCE_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSpacePersistence</name></member> + </type> + + <type category="struct" name="XrSpacesSaveInfoMETA"> + <member values="XR_TYPE_SPACES_SAVE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>spaceCount</name></member> + <member len="spaceCount"><type>XrSpace</type>* <name>spaces</name></member> + </type> + + <type category="struct" name="XrEventDataSpacesSaveResultMETA" returnedonly="true" parentstruct="XrEventDataBaseHeader"> + <member values="XR_TYPE_EVENT_DATA_SPACES_SAVE_RESULT_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + + <type category="struct" name="XrSpacesEraseInfoMETA"> + <member values="XR_TYPE_SPACES_ERASE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>spaceCount</name></member> + <member len="spaceCount" optional="true"><type>XrSpace</type>* <name>spaces</name></member> + <member optional="true"><type>uint32_t</type> <name>uuidCount</name></member> + <member len="uuidCount" optional="true"><type>XrUuidEXT</type>* <name>uuids</name></member> + </type> + + <type category="struct" name="XrEventDataSpacesEraseResultMETA" returnedonly="true" parentstruct="XrEventDataBaseHeader"> + <member values="XR_TYPE_EVENT_DATA_SPACES_ERASE_RESULT_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + + <!-- XR_META_spatial_entity_discovery structs --> + <type category="struct" name="XrSystemSpaceDiscoveryPropertiesMETA" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_SPACE_DISCOVERY_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSpaceDiscovery</name></member> + </type> + + <type category="struct" name="XrSpaceFilterBaseHeaderMETA"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrSpaceDiscoveryInfoMETA"> + <member values="XR_TYPE_SPACE_DISCOVERY_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>filterCount</name></member> + <member optional="true" len="filterCount">const <type>XrSpaceFilterBaseHeaderMETA</type>* const * <name>filters</name></member> + </type> + + <type category="struct" name="XrSpaceFilterUuidMETA" parentstruct="XrSpaceFilterBaseHeaderMETA"> + <member values="XR_TYPE_SPACE_FILTER_UUID_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>uuidCount</name></member> + <member len="uuidCount">const <type>XrUuidEXT</type>* <name>uuids</name></member> + </type> + + <type category="struct" name="XrSpaceFilterComponentMETA" parentstruct="XrSpaceFilterBaseHeaderMETA"> + <member values="XR_TYPE_SPACE_FILTER_COMPONENT_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpaceComponentTypeFB</type> <name>componentType</name></member> + </type> + + <type category="struct" name="XrSpaceDiscoveryResultMETA" returnedonly="true"> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + </type> + + <type category="struct" name="XrSpaceDiscoveryResultsMETA"> + <member values="XR_TYPE_SPACE_DISCOVERY_RESULTS_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>resultCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>resultCountOutput</name></member> + <member optional="true" len="resultCapacityInput"><type>XrSpaceDiscoveryResultMETA</type>* <name>results</name></member> + </type> + + <type category="struct" name="XrEventDataSpaceDiscoveryResultsAvailableMETA" returnedonly="true" parentstruct="XrEventDataBaseHeader"> + <member values="XR_TYPE_EVENT_DATA_SPACE_DISCOVERY_RESULTS_AVAILABLE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + </type> + + <type category="struct" name="XrEventDataSpaceDiscoveryCompleteMETA" returnedonly="true" parentstruct="XrEventDataBaseHeader"> + <member values="XR_TYPE_EVENT_DATA_SPACE_DISCOVERY_COMPLETE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAsyncRequestIdFB</type> <name>requestId</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + + <!-- XR_META_passthrough_color_lut types --> + <type category="struct" name="XrPassthroughColorLutDataMETA"> + <member><type>uint32_t</type> <name>bufferSize</name></member> + <member len="bufferSize">const <type>uint8_t</type>* <name>buffer</name></member> + </type> + + <type category="struct" name="XrPassthroughColorLutCreateInfoMETA"> + <member values="XR_TYPE_PASSTHROUGH_COLOR_LUT_CREATE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPassthroughColorLutChannelsMETA</type> <name>channels</name></member> + <member><type>uint32_t</type> <name>resolution</name></member> + <member><type>XrPassthroughColorLutDataMETA</type> <name>data</name></member> + </type> + + <type category="struct" name="XrPassthroughColorLutUpdateInfoMETA"> + <member values="XR_TYPE_PASSTHROUGH_COLOR_LUT_UPDATE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPassthroughColorLutDataMETA</type> <name>data</name></member> + </type> + + <type category="struct" name="XrPassthroughColorMapLutMETA" structextends="XrPassthroughStyleFB"> + <member values="XR_TYPE_PASSTHROUGH_COLOR_MAP_LUT_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPassthroughColorLutMETA</type> <name>colorLut</name></member> + <member><type>float</type> <name>weight</name></member> + </type> + + <type category="struct" name="XrPassthroughColorMapInterpolatedLutMETA" structextends="XrPassthroughStyleFB"> + <member values="XR_TYPE_PASSTHROUGH_COLOR_MAP_INTERPOLATED_LUT_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPassthroughColorLutMETA</type> <name>sourceColorLut</name></member> + <member><type>XrPassthroughColorLutMETA</type> <name>targetColorLut</name></member> + <member><type>float</type> <name>weight</name></member> + </type> + + <type category="struct" name="XrSystemPassthroughColorLutPropertiesMETA" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_PASSTHROUGH_COLOR_LUT_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>maxColorLutResolution</name></member> + </type> + + <!-- XR_HTC_foveation structs --> + <type category="struct" name="XrFoveationApplyInfoHTC"> + <member values="XR_TYPE_FOVEATION_APPLY_INFO_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrFoveationModeHTC</type> <name>mode</name></member> + <member><type>uint32_t</type> <name>subImageCount</name></member> + <member len="subImageCount"><type>XrSwapchainSubImage</type>* <name>subImages</name></member> + </type> + <type category="struct" name="XrFoveationConfigurationHTC"> + <member><type>XrFoveationLevelHTC</type> <name>level</name></member> + <member><type>float</type> <name>clearFovDegree</name></member> + <member><type>XrVector2f</type> <name>focalCenterOffset</name></member> + </type> + <type category="struct" name="XrFoveationDynamicModeInfoHTC" structextends="XrFoveationApplyInfoHTC"> + <member values="XR_TYPE_FOVEATION_DYNAMIC_MODE_INFO_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrFoveationDynamicFlagsHTC</type> <name>dynamicFlags</name></member> + </type> + <type category="struct" name="XrFoveationCustomModeInfoHTC" structextends="XrFoveationApplyInfoHTC"> + <member values="XR_TYPE_FOVEATION_CUSTOM_MODE_INFO_HTC"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>configCount</name></member> + <member len="configCount">const <type>XrFoveationConfigurationHTC</type>* <name>configs</name></member> + </type> + + <!-- XR_EXT_active_action_set_priority --> + <type category="struct" name="XrActiveActionSetPrioritiesEXT" structextends="XrActionsSyncInfo"> + <member values="XR_TYPE_ACTIVE_ACTION_SET_PRIORITIES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>actionSetPriorityCount</name></member> + <member len="actionSetPriorityCount">const <type>XrActiveActionSetPriorityEXT</type>* <name>actionSetPriorities</name></member> + </type> + + <type category="struct" name="XrActiveActionSetPriorityEXT"> + <member><type>XrActionSet</type> <name>actionSet</name></member> + <member><type>uint32_t</type> <name>priorityOverride</name></member> + </type> + + <!-- XR_FB_composition_layer_depth_test --> + <type category="struct" name="XrCompositionLayerDepthTestFB" structextends="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_DEPTH_TEST_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>depthMask</name></member> + <member><type>XrCompareOpFB</type> <name>compareOp</name></member> + </type> + <!-- XR_ML_compat structs --> + <type category="struct" name="XrCoordinateSpaceCreateInfoML"> + <member values="XR_TYPE_COORDINATE_SPACE_CREATE_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>MLCoordinateFrameUID</type> <name>cfuid</name></member> + <member><type>XrPosef</type> <name>poseInCoordinateSpace</name></member> + </type> + + + <!-- XR_ML_frame_end_info structs --> + <type category="struct" name="XrFrameEndInfoML" structextends="XrFrameEndInfo"> + <member values="XR_TYPE_FRAME_END_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>focusDistance</name></member> + <member optional="true"><type>XrFrameEndInfoFlagsML</type> <name>flags</name></member> + </type> + + <!-- XR_FB_haptic_amplitude_envelope struct --> + <type category="struct" name="XrHapticAmplitudeEnvelopeVibrationFB" parentstruct="XrHapticBaseHeader"> + <member values="XR_TYPE_HAPTIC_AMPLITUDE_ENVELOPE_VIBRATION_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrDuration</type> <name>duration</name></member> + <member><type>uint32_t</type> <name>amplitudeCount</name></member> + <member len="amplitudeCount">const <type>float</type>* <name>amplitudes</name></member> + </type> + + <!-- XR_FB_haptic_pcm structs --> + <type category="struct" name="XrHapticPcmVibrationFB" parentstruct="XrHapticBaseHeader"> + <member values="XR_TYPE_HAPTIC_PCM_VIBRATION_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>bufferSize</name></member> + <member len="bufferSize">const <type>float</type>* <name>buffer</name></member> + <member><type>float</type> <name>sampleRate</name></member> + <member><type>XrBool32</type> <name>append</name></member> + <member><type>uint32_t</type>* <name>samplesConsumed</name></member> + </type> + <type category="struct" name="XrDevicePcmSampleRateStateFB"> + <member values="XR_TYPE_DEVICE_PCM_SAMPLE_RATE_STATE_FB"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>float</type> <name>sampleRate</name></member> + </type> + + <type category="struct" name="XrDevicePcmSampleRateGetInfoFB" alias="XrDevicePcmSampleRateStateFB"/> + + <!-- XR_FB_spatial_entity_user --> + <type category="struct" name="XrSpaceUserCreateInfoFB"> + <member values="XR_TYPE_SPACE_USER_CREATE_INFO_FB"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpaceUserIdFB</type> <name>userId</name></member> + </type> + + <!-- XR_MNDX_force_feedback_curl --> + <type category="struct" name="XrSystemForceFeedbackCurlPropertiesMNDX" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_FORCE_FEEDBACK_CURL_PROPERTIES_MNDX"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsForceFeedbackCurl</name></member> + </type> + + <type category="struct" name="XrForceFeedbackCurlApplyLocationsMNDX"> + <member values="XR_TYPE_FORCE_FEEDBACK_CURL_APPLY_LOCATIONS_MNDX"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>locationCount</name></member> + <member len="locationCount"><type>XrForceFeedbackCurlApplyLocationMNDX</type>* <name>locations</name></member> + </type> + + <type category="struct" name="XrForceFeedbackCurlApplyLocationMNDX"> + <member><type>XrForceFeedbackCurlLocationMNDX</type> <name>location</name></member> + <member><type>float</type> <name>value</name></member> + </type> + + <!-- XR_ANDROID_face_tracking --> + <type category="struct" name="XrFaceTrackerCreateInfoANDROID"> + <member values="XR_TYPE_FACE_TRACKER_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrFaceStateGetInfoANDROID"> + <member values="XR_TYPE_FACE_STATE_GET_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrFaceStateANDROID"> + <member values="XR_TYPE_FACE_STATE_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>parametersCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>parametersCountOutput</name></member> + <member optional="true" len="parametersCapacityInput"><type>float</type>* <name>parameters</name></member> + <member><type>XrFaceTrackingStateANDROID</type> <name>faceTrackingState</name></member> + <member><type>XrTime</type> <name>sampleTime</name></member> + <member><type>XrBool32</type> <name>isValid</name></member> + <member optional="true"><type>uint32_t</type> <name>regionConfidencesCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>regionConfidencesCountOutput</name></member> + <member optional="true" len="regionConfidencesCapacityInput"><type>float</type>* <name>regionConfidences</name></member> + </type> + <type category="struct" name="XrSystemFaceTrackingPropertiesANDROID" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsFaceTracking</name></member> + </type> + + <!-- XR_ANDROID_passthrough_camera_state --> + <type category="struct" name="XrSystemPassthroughCameraStatePropertiesANDROID" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_PASSTHROUGH_CAMERA_STATE_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsPassthroughCameraState</name></member> + </type> + <type category="struct" name="XrPassthroughCameraStateGetInfoANDROID"> + <member values="XR_TYPE_PASSTHROUGH_CAMERA_STATE_GET_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <!-- XR_ANDROID_trackables_object --> + <type category="struct" name="XrTrackableObjectANDROID"> + <member values="XR_TYPE_TRACKABLE_OBJECT_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrTrackingStateANDROID</type> <name>trackingState</name></member> + <member><type>XrPosef</type> <name>centerPose</name></member> + <member><type>XrExtent3DfEXT</type> <name>extents</name></member> + <member><type>XrObjectLabelANDROID</type> <name>objectLabel</name></member> + <member><type>XrTime</type> <name>lastUpdatedTime</name></member> + </type> + <type category="struct" name="XrTrackableObjectConfigurationANDROID" structextends="XrTrackableTrackerCreateInfoANDROID"> + <member values="XR_TYPE_TRACKABLE_OBJECT_CONFIGURATION_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>labelCount</name></member> + <member len="labelCount">const <type>XrObjectLabelANDROID</type>* <name>activeLabels</name></member> + </type> + + <!-- XR_ANDROID_raycast --> + <type category="struct" name="XrRaycastInfoANDROID"> + <member values="XR_TYPE_RAYCAST_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>maxResults</name></member> + <member><type>uint32_t</type> <name>trackerCount</name></member> + <member len="trackerCount">const <type>XrTrackableTrackerANDROID</type>* <name>trackers</name></member> + <member><type>XrVector3f</type> <name>origin</name></member> + <member><type>XrVector3f</type> <name>trajectory</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrRaycastHitResultANDROID" returnedonly="true"> + <member noautovalidity="true"><type>XrTrackableTypeANDROID</type> <name>type</name></member> + <member><type>XrTrackableANDROID</type> <name>trackable</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrRaycastHitResultsANDROID"> + <member values="XR_TYPE_RAYCAST_HIT_RESULTS_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>resultsCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>resultsCountOutput</name></member> + <member optional="true" len="resultsCapacityInput"><type>XrRaycastHitResultANDROID</type>* <name>results</name></member> + </type> + + <!-- XR_ANDROID_trackables_marker --> + <type category="struct" name="XrSystemMarkerTrackingPropertiesANDROID" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsMarkerTracking</name></member> + <member><type>XrBool32</type> <name>supportsMarkerSizeEstimation</name></member> + <member><type>uint16_t</type> <name>maxMarkerCount</name></member> + </type> + <type category="struct" name="XrTrackableMarkerConfigurationANDROID" structextends="XrTrackableTrackerCreateInfoANDROID"> + <member values="XR_TYPE_TRACKABLE_MARKER_CONFIGURATION_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrTrackableMarkerTrackingModeANDROID</type> <name>trackingMode</name></member> + <member><type>uint32_t</type> <name>databaseCount</name></member> + <member len="databaseCount">const <type>XrTrackableMarkerDatabaseANDROID</type>* <name>databases</name></member> + </type> + <type category="struct" name="XrTrackableMarkerDatabaseANDROID"> + <member><type>XrTrackableMarkerDictionaryANDROID</type> <name>dictionary</name></member> + <member optional="true"><type>uint32_t</type> <name>entryCount</name></member> + <member len="entryCount">const <type>XrTrackableMarkerDatabaseEntryANDROID</type>* <name>entries</name></member> + </type> + <type category="struct" name="XrTrackableMarkerDatabaseEntryANDROID"> + <member><type>int32_t</type> <name>id</name></member> + <member><type>float</type> <name>edgeSize</name></member> + </type> + <type category="struct" name="XrTrackableMarkerANDROID"> + <member values="XR_TYPE_TRACKABLE_MARKER_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrTrackingStateANDROID</type> <name>trackingState</name></member> + <member><type>XrTime</type> <name>lastUpdatedTime</name></member> + <member><type>XrTrackableMarkerDictionaryANDROID</type> <name>dictionary</name></member> + <member><type>int32_t</type> <name>markerId</name></member> + <member><type>XrPosef</type> <name>centerPose</name></member> + <member><type>XrExtent2Df</type> <name>extents</name></member> + </type> + + <!-- XR_ANDROID_anchor_sharing_export --> + <type category="struct" name="XrSystemAnchorSharingExportPropertiesANDROID" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_ANCHOR_SHARING_EXPORT_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsAnchorSharingExport</name></member> + </type> + <type category="struct" name="XrAnchorSharingInfoANDROID"> + <member values="XR_TYPE_ANCHOR_SHARING_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>anchor</name></member> + </type> + <type category="struct" name="XrAnchorSharingTokenANDROID" returnedonly="true"> + <member values="XR_TYPE_ANCHOR_SHARING_TOKEN_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member>struct <type>AIBinder</type>* <name>token</name></member> + </type> + + <!-- XR_ANDROID_device_anchor_persistence --> + <type category="struct" name="XrDeviceAnchorPersistenceCreateInfoANDROID"> + <member values="XR_TYPE_DEVICE_ANCHOR_PERSISTENCE_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrPersistedAnchorSpaceCreateInfoANDROID"> + <member values="XR_TYPE_PERSISTED_ANCHOR_SPACE_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrUuidEXT</type> <name>anchorId</name></member> + </type> + <type category="struct" name="XrPersistedAnchorSpaceInfoANDROID"> + <member values="XR_TYPE_PERSISTED_ANCHOR_SPACE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>anchor</name></member> + </type> + <type category="struct" name="XrSystemDeviceAnchorPersistencePropertiesANDROID" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_DEVICE_ANCHOR_PERSISTENCE_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsAnchorPersistence</name></member> + </type> + + <!-- XR_ANDROID_performance_metrics --> + <type category="struct" name="XrPerformanceMetricsStateANDROID"> + <member values="XR_TYPE_PERFORMANCE_METRICS_STATE_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>enabled</name></member> + </type> + <type category="struct" name="XrPerformanceMetricsCounterANDROID" returnedonly="true"> + <member values="XR_TYPE_PERFORMANCE_METRICS_COUNTER_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrPerformanceMetricsCounterFlagsANDROID</type> <name>counterFlags</name></member> + <member><type>XrPerformanceMetricsCounterUnitANDROID</type> <name>counterUnit</name></member> + <member><type>uint32_t</type> <name>uintValue</name></member> + <member><type>float</type> <name>floatValue</name></member> + </type> + + <!-- XR_ANDROID_trackables_qr_code --> + <type category="struct" name="XrSystemQrCodeTrackingPropertiesANDROID" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_QR_CODE_TRACKING_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsQrCodeTracking</name></member> + <member><type>XrBool32</type> <name>supportsQrCodeSizeEstimation</name></member> + <member><type>uint16_t</type> <name>maxQrCodeCount</name></member> + </type> + <type category="struct" name="XrTrackableQrCodeConfigurationANDROID" structextends="XrTrackableTrackerCreateInfoANDROID"> + <member values="XR_TYPE_TRACKABLE_QR_CODE_CONFIGURATION_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrQrCodeTrackingModeANDROID</type> <name>trackingMode</name></member> + <member><type>float</type> <name>qrCodeEdgeSize</name></member> + </type> + <type category="struct" name="XrTrackableQrCodeANDROID"> + <member values="XR_TYPE_TRACKABLE_QR_CODE_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrTrackingStateANDROID</type> <name>trackingState</name></member> + <member><type>XrTime</type> <name>lastUpdatedTime</name></member> + <member><type>XrPosef</type> <name>centerPose</name></member> + <member><type>XrExtent2Df</type> <name>extents</name></member> + <member optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>bufferCountOutput</name></member> + <member len="bufferCapacityInput" optional="true"><type>char</type>* <name>buffer</name></member> + </type> + + <!-- XR_ANDROID_composition_layer_passthrough_mesh --> + <type category="struct" name="XrSystemPassthroughLayerPropertiesANDROID" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_PASSTHROUGH_LAYER_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsPassthroughLayer</name></member> + <member><type>uint32_t</type> <name>maxMeshIndexCount</name></member> + <member><type>uint32_t</type> <name>maxMeshVertexCount</name></member> + </type> + <type category="struct" name="XrPassthroughLayerCreateInfoANDROID"> + <member values="XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>vertexCapacity</name></member> + <member><type>uint32_t</type> <name>indexCapacity</name></member> + </type> + <type category="struct" name="XrPassthroughLayerMeshANDROID" structextends="XrPassthroughLayerCreateInfoANDROID"> + <member values="XR_TYPE_PASSTHROUGH_LAYER_MESH_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrWindingOrderANDROID</type> <name>windingOrder</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCount</name></member> + <member len="vertexCount">const <type>XrVector3f</type>* <name>vertices</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCount</name></member> + <member len="indexCount">const <type>uint16_t</type>* <name>indices</name></member> + </type> + <type category="struct" name="XrCompositionLayerPassthroughANDROID" parentstruct="XrCompositionLayerBaseHeader"> + <member values="XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrCompositionLayerFlags</type> <name>layerFlags</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrVector3f</type> <name>scale</name></member> + <member><type>float</type> <name>opacity</name></member> + <member><type>XrPassthroughLayerANDROID</type> <name>layer</name></member> + </type> + + <!-- XR_ANDROID_scene_meshing --> + <type category="struct" name="XrSystemSceneMeshingPropertiesANDROID" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_SCENE_MESHING_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSceneMeshing</name></member> + </type> + <type category="struct" name="XrSceneMeshingTrackerCreateInfoANDROID"> + <member values="XR_TYPE_SCENE_MESHING_TRACKER_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSceneMeshSemanticLabelSetANDROID</type> <name>semanticLabelSet</name></member> + <member><type>XrBool32</type> <name>enableNormals</name></member> + </type> + <type category="struct" name="XrSceneMeshSnapshotCreateInfoANDROID"> + <member values="XR_TYPE_SCENE_MESH_SNAPSHOT_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrBoxf</type> <name>boundingBox</name></member> + </type> + <type category="struct" name="XrSceneMeshSnapshotCreationResultANDROID"> + <member values="XR_TYPE_SCENE_MESH_SNAPSHOT_CREATION_RESULT_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSceneMeshSnapshotANDROID</type> <name>snapshot</name></member> + <member><type>XrSceneMeshTrackingStateANDROID</type> <name>trackingState</name></member> + </type> + <type category="struct" name="XrSceneSubmeshStateANDROID"> + <member values="XR_TYPE_SCENE_SUBMESH_STATE_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrUuid</type> <name>submeshId</name></member> + <member><type>XrTime</type> <name>lastUpdatedTime</name></member> + <member><type>XrPosef</type> <name>submeshPoseInBaseSpace</name></member> + <member><type>XrExtent3Df</type> <name>bounds</name></member> + </type> + <type category="struct" name="XrSceneSubmeshDataANDROID"> + <member values="XR_TYPE_SCENE_SUBMESH_DATA_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrUuid</type> <name>submeshId</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCountOutput</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector3f</type>* <name>vertexPositions</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector3f</type>* <name>vertexNormals</name></member> + <member optional="true" len="vertexCapacityInput"><type>uint8_t</type>* <name>vertexSemantics</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCountOutput</name></member> + <member optional="true" len="indexCapacityInput"><type>uint32_t</type>* <name>indices</name></member> + </type> + + <!-- XR_ANDROID_eye_tracking --> + <type category="struct" name="XrSystemEyeTrackingPropertiesANDROID" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_EYE_TRACKING_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsEyeTracking</name></member> + </type> + <type category="struct" name="XrEyeANDROID"> + <member><type>XrEyeStateANDROID</type> <name>eyeState</name></member> + <member><type>XrPosef</type> <name>eyePose</name></member> + </type> + <type category="struct" name="XrEyesANDROID"> + <member values="XR_TYPE_EYES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrEyeANDROID</type> <name>eyes</name>[<enum>XR_EYE_MAX_ANDROID</enum>]</member> + <member><type>XrEyeTrackingModeANDROID</type> <name>mode</name></member> + </type> + <type category="struct" name="XrEyesGetInfoANDROID"> + <member values="XR_TYPE_EYES_GET_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + </type> + <type category="struct" name="XrEyeTrackerCreateInfoANDROID"> + <member values="XR_TYPE_EYE_TRACKER_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <!-- XR_ANDROID_recommended_resolution --> + <type category="struct" name="XrEventDataRecommendedResolutionChangedANDROID" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_RECOMMENDED_RESOLUTION_CHANGED_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <!-- XR_ANDROID_light_estimation --> + <type category="struct" name="XrSystemLightEstimationPropertiesANDROID" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_LIGHT_ESTIMATION_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsLightEstimation</name></member> + </type> + <type category="struct" name="XrLightEstimatorCreateInfoANDROID"> + <member values="XR_TYPE_LIGHT_ESTIMATOR_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrLightEstimateGetInfoANDROID"> + <member values="XR_TYPE_LIGHT_ESTIMATE_GET_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrLightEstimateANDROID"> + <member values="XR_TYPE_LIGHT_ESTIMATE_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrLightEstimateStateANDROID</type> <name>state</name></member> + <member><type>XrTime</type> <name>lastUpdatedTime</name></member> + </type> + <type category="struct" name="XrDirectionalLightANDROID" structextends="XrLightEstimateANDROID"> + <member values="XR_TYPE_DIRECTIONAL_LIGHT_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrLightEstimateStateANDROID</type> <name>state</name></member> + <member><type>XrVector3f</type> <name>intensity</name></member> + <member><type>XrVector3f</type> <name>direction</name></member> + </type> + <type category="struct" name="XrAmbientLightANDROID" structextends="XrLightEstimateANDROID"> + <member values="XR_TYPE_AMBIENT_LIGHT_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrLightEstimateStateANDROID</type> <name>state</name></member> + <member><type>XrVector3f</type> <name>intensity</name></member> + <member><type>XrVector3f</type> <name>colorCorrection</name></member> + </type> + <type category="struct" name="XrSphericalHarmonicsANDROID" structextends="XrLightEstimateANDROID"> + <member values="XR_TYPE_SPHERICAL_HARMONICS_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrLightEstimateStateANDROID</type> <name>state</name></member> + <member><type>XrSphericalHarmonicsKindANDROID</type> <name>kind</name></member> + <member><type>float</type> <name>coefficients</name>[9][3]</member> + </type> + + <!-- XR_EXT_plane_detection --> + <type category="struct" name="XrSystemPlaneDetectionPropertiesEXT" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_PLANE_DETECTION_PROPERTIES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrPlaneDetectionCapabilityFlagsEXT</type> <name>supportedFeatures</name></member> + </type> + + <type category="struct" name="XrPlaneDetectorCreateInfoEXT"> + <member values="XR_TYPE_PLANE_DETECTOR_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrPlaneDetectorFlagsEXT</type> <name>flags</name></member> + </type> + + <type category="struct" name="XrPlaneDetectorBeginInfoEXT"> + <member values="XR_TYPE_PLANE_DETECTOR_BEGIN_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member optional="true"><type>uint32_t</type> <name>orientationCount</name></member> + <member optional="true" len="orientationCount">const <type>XrPlaneDetectorOrientationEXT</type>* <name>orientations</name></member> + <member optional="true"><type>uint32_t</type> <name>semanticTypeCount</name></member> + <member optional="true" len="semanticTypeCount">const <type>XrPlaneDetectorSemanticTypeEXT</type>* <name>semanticTypes</name></member> + <member><type>uint32_t</type> <name>maxPlanes</name></member> + <member><type>float</type> <name>minArea</name></member> + <member><type>XrPosef</type> <name>boundingBoxPose</name></member> + <member><type>XrExtent3DfEXT</type> <name>boundingBoxExtent</name></member> + </type> + + <type category="struct" name="XrPlaneDetectorGetInfoEXT"> + <member values="XR_TYPE_PLANE_DETECTOR_GET_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <type category="struct" name="XrPlaneDetectorLocationsEXT"> + <member values="XR_TYPE_PLANE_DETECTOR_LOCATIONS_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>planeLocationCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>planeLocationCountOutput</name></member> + <member optional="true" len="planeLocationCapacityInput"><type>XrPlaneDetectorLocationEXT</type>* <name>planeLocations</name></member> + </type> + + <type category="struct" name="XrPlaneDetectorLocationEXT"> + <member values="XR_TYPE_PLANE_DETECTOR_LOCATION_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint64_t</type> <name>planeId</name></member> + <member optional="true"><type>XrSpaceLocationFlags</type> <name>locationFlags</name></member> + <member optional="true"><type>XrPosef</type> <name>pose</name></member> + <member optional="true"><type>XrExtent2Df</type> <name>extents</name></member> + <member optional="true"><type>XrPlaneDetectorOrientationEXT</type> <name>orientation</name></member> + <member optional="true"><type>XrPlaneDetectorSemanticTypeEXT</type> <name>semanticType</name></member> + <member optional="true"><type>uint32_t</type> <name>polygonBufferCount</name></member> + </type> + + <type category="struct" name="XrPlaneDetectorPolygonBufferEXT"> + <member values="XR_TYPE_PLANE_DETECTOR_POLYGON_BUFFER_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCountOutput</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector2f</type>* <name>vertices</name></member> + </type> + + <!-- XR_META_virtual_keyboard --> + <type category="struct" name="XrSystemVirtualKeyboardPropertiesMETA" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_VIRTUAL_KEYBOARD_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsVirtualKeyboard</name></member> + </type> + + <type category="struct" name="XrVirtualKeyboardCreateInfoMETA"> + <member values="XR_TYPE_VIRTUAL_KEYBOARD_CREATE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrVirtualKeyboardSpaceCreateInfoMETA"> + <member values="XR_TYPE_VIRTUAL_KEYBOARD_SPACE_CREATE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrVirtualKeyboardLocationTypeMETA</type> <name>locationType</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrPosef</type> <name>poseInSpace</name></member> + </type> + + <type category="struct" name="XrVirtualKeyboardLocationInfoMETA"> + <member values="XR_TYPE_VIRTUAL_KEYBOARD_LOCATION_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrVirtualKeyboardLocationTypeMETA</type> <name>locationType</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrPosef</type> <name>poseInSpace</name></member> + <member><type>float</type> <name>scale</name></member> + </type> + + <type category="struct" name="XrVirtualKeyboardModelVisibilitySetInfoMETA"> + <member values="XR_TYPE_VIRTUAL_KEYBOARD_MODEL_VISIBILITY_SET_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>visible</name></member> + </type> + + <type category="struct" name="XrVirtualKeyboardAnimationStateMETA"> + <member values="XR_TYPE_VIRTUAL_KEYBOARD_ANIMATION_STATE_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>int32_t</type> <name>animationIndex</name></member> + <member><type>float</type> <name>fraction</name></member> + </type> + + <type category="struct" name="XrVirtualKeyboardModelAnimationStatesMETA"> + <member values="XR_TYPE_VIRTUAL_KEYBOARD_MODEL_ANIMATION_STATES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>stateCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>stateCountOutput</name></member> + <member len="stateCapacityInput" optional="true"><type>XrVirtualKeyboardAnimationStateMETA</type>* <name>states</name></member> + </type> + + <type category="struct" name="XrVirtualKeyboardTextureDataMETA"> + <member values="XR_TYPE_VIRTUAL_KEYBOARD_TEXTURE_DATA_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>textureWidth</name></member> + <member><type>uint32_t</type> <name>textureHeight</name></member> + <member optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>bufferCountOutput</name></member> + <member len="bufferCapacityInput" optional="true"><type>uint8_t</type>* <name>buffer</name></member> + </type> + + <type category="struct" name="XrVirtualKeyboardInputInfoMETA"> + <member values="XR_TYPE_VIRTUAL_KEYBOARD_INPUT_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrVirtualKeyboardInputSourceMETA</type> <name>inputSource</name></member> + <member optional="true"><type>XrSpace</type> <name>inputSpace</name></member> + <member optional="true"><type>XrPosef</type> <name>inputPoseInSpace</name></member> + <member optional="true"><type>XrVirtualKeyboardInputStateFlagsMETA</type> <name>inputState</name></member> + </type> + + <type category="struct" name="XrVirtualKeyboardTextContextChangeInfoMETA"> + <member values="XR_TYPE_VIRTUAL_KEYBOARD_TEXT_CONTEXT_CHANGE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member len="null-terminated">const <type>char</type>* <name>textContext</name></member> + </type> + + <type category="struct" name="XrEventDataVirtualKeyboardCommitTextMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_COMMIT_TEXT_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></member> + <member><type>char</type> <name>text</name>[<enum>XR_MAX_VIRTUAL_KEYBOARD_COMMIT_TEXT_SIZE_META</enum>]</member> + </type> + + <type category="struct" name="XrEventDataVirtualKeyboardBackspaceMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_BACKSPACE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></member> + </type> + + <type category="struct" name="XrEventDataVirtualKeyboardEnterMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_ENTER_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></member> + </type> + + <type category="struct" name="XrEventDataVirtualKeyboardShownMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_SHOWN_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></member> + </type> + + <type category="struct" name="XrEventDataVirtualKeyboardHiddenMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_HIDDEN_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></member> + </type> + + <!-- XR_ML_user_calibration --> + <type category="struct" name="XrUserCalibrationEnableEventsInfoML"> + <member values="XR_TYPE_USER_CALIBRATION_ENABLE_EVENTS_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>enabled</name></member> + </type> + + <type category="struct" name="XrEventDataHeadsetFitChangedML" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_HEADSET_FIT_CHANGED_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrHeadsetFitStatusML</type> <name>status</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <type category="struct" name="XrEventDataEyeCalibrationChangedML" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_EYE_CALIBRATION_CHANGED_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrEyeCalibrationStatusML</type> <name>status</name></member> + </type> + + <!-- XR_ML_localization_map --> + <type category="struct" name="XrLocalizationMapML"> + <member values="XR_TYPE_LOCALIZATION_MAP_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>char</type> <name>name</name>[<enum>XR_MAX_LOCALIZATION_MAP_NAME_LENGTH_ML</enum>]</member> + <member optional="true"><type>XrUuidEXT</type> <name>mapUuid</name></member> + <member optional="true"><type>XrLocalizationMapTypeML</type> <name>mapType</name></member> + </type> + + <type category="struct" name="XrLocalizationEnableEventsInfoML"> + <member values="XR_TYPE_LOCALIZATION_ENABLE_EVENTS_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>enabled</name></member> + </type> + + <type category="struct" name="XrEventDataLocalizationChangedML" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_LOCALIZATION_CHANGED_ML"> <type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSession</type> <name>session</name></member> + <member><type>XrLocalizationMapStateML</type> <name>state</name></member> + <member><type>XrLocalizationMapML</type> <name>map</name></member> + <member><type>XrLocalizationMapConfidenceML</type> <name>confidence</name></member> + <member><type>XrLocalizationMapErrorFlagsML</type> <name>errorFlags</name></member> + </type> + + <type category="struct" name="XrLocalizationMapQueryInfoBaseHeaderML"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrMapLocalizationRequestInfoML"> + <member values="XR_TYPE_MAP_LOCALIZATION_REQUEST_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrUuidEXT</type> <name>mapUuid</name></member> + </type> + + <type category="struct" name="XrLocalizationMapImportInfoML"> + <member values="XR_TYPE_LOCALIZATION_MAP_IMPORT_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>size</name></member> + <member len="size"><type>char</type>* <name>data</name></member> + </type> + + + <!-- XR_ML_marker_understanding --> + <type category="struct" name="XrSystemMarkerUnderstandingPropertiesML" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_MARKER_UNDERSTANDING_PROPERTIES_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsMarkerUnderstanding</name></member> + </type> + + <type category="struct" name="XrMarkerDetectorCreateInfoML"> + <member values="XR_TYPE_MARKER_DETECTOR_CREATE_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrMarkerDetectorProfileML</type> <name>profile</name></member> + <member><type>XrMarkerTypeML</type> <name>markerType</name></member> + </type> + + <type category="struct" name="XrMarkerDetectorArucoInfoML" structextends="XrMarkerDetectorCreateInfoML"> + <member values="XR_TYPE_MARKER_DETECTOR_ARUCO_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrMarkerArucoDictML</type> <name>arucoDict</name></member> + </type> + + <type category="struct" name="XrMarkerDetectorSizeInfoML" structextends="XrMarkerDetectorCreateInfoML"> + <member values="XR_TYPE_MARKER_DETECTOR_SIZE_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>markerLength</name></member> + </type> + + <type category="struct" name="XrMarkerDetectorAprilTagInfoML" structextends="XrMarkerDetectorCreateInfoML"> + <member values="XR_TYPE_MARKER_DETECTOR_APRIL_TAG_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrMarkerAprilTagDictML</type> <name>aprilTagDict</name></member> + </type> + + <type category="struct" name="XrMarkerDetectorCustomProfileInfoML" structextends="XrMarkerDetectorCreateInfoML"> + <member values="XR_TYPE_MARKER_DETECTOR_CUSTOM_PROFILE_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrMarkerDetectorFpsML</type> <name>fpsHint</name></member> + <member><type>XrMarkerDetectorResolutionML</type> <name>resolutionHint</name></member> + <member><type>XrMarkerDetectorCameraML</type> <name>cameraHint</name></member> + <member><type>XrMarkerDetectorCornerRefineMethodML</type> <name>cornerRefineMethod</name></member> + <member><type>XrBool32</type> <name>useEdgeRefinement</name></member> + <member><type>XrMarkerDetectorFullAnalysisIntervalML</type> <name>fullAnalysisIntervalHint</name></member> + </type> + + <type category="struct" name="XrMarkerDetectorSnapshotInfoML"> + <member values="XR_TYPE_MARKER_DETECTOR_SNAPSHOT_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrMarkerDetectorStateML" returnedonly="true"> + <member values="XR_TYPE_MARKER_DETECTOR_STATE_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrMarkerDetectorStatusML</type> <name>state</name></member> + </type> + + <type category="struct" name="XrMarkerSpaceCreateInfoML"> + <member values="XR_TYPE_MARKER_SPACE_CREATE_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrMarkerDetectorML</type> <name>markerDetector</name></member> + <member><type>XrMarkerML</type> <name>marker</name></member> + <member><type>XrPosef</type> <name>poseInMarkerSpace</name></member> + </type> + + <type category="struct" name="XrColor3f"> + <member><type>float</type> <name>r</name></member> + <member><type>float</type> <name>g</name></member> + <member><type>float</type> <name>b</name></member> + </type> + + <type category="struct" name="XrExtent3Df"> + <member><type>float</type> <name>width</name></member> + <member><type>float</type> <name>height</name></member> + <member><type>float</type> <name>depth</name></member> + </type> + + <type category="struct" name="XrSpheref"> + <member><type>XrPosef</type> <name>center</name></member> + <member><type>float</type> <name>radius</name></member> + </type> + + <type category="struct" name="XrBoxf"> + <member><type>XrPosef</type> <name>center</name></member> + <member><type>XrExtent3Df</type> <name>extents</name></member> + </type> + + <type category="struct" name="XrFrustumf"> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrFovf</type> <name>fov</name></member> + <member><type>float</type> <name>nearZ</name></member> + <member><type>float</type> <name>farZ</name></member> + </type> + + <type category="struct" name="XrUuid"> + <member><type>uint8_t</type> <name>data</name>[XR_UUID_SIZE]</member> + </type> + + <!-- XR_KHR_maintenance1 --> + <type category="struct" name="XrColor3fKHR" alias="XrColor3f"/> + + <type category="struct" name="XrExtent3DfKHR" alias="XrExtent3Df"/> + + <type category="struct" name="XrSpherefKHR" alias="XrSpheref"/> + + <type category="struct" name="XrBoxfKHR" alias="XrBoxf"/> + + <type category="struct" name="XrFrustumfKHR" alias="XrFrustumf"/> + + <!-- XR_ML_facial_expression --> + <type category="struct" name="XrSystemFacialExpressionPropertiesML" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_FACIAL_EXPRESSION_PROPERTIES_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsFacialExpression</name></member> + </type> + <type category="struct" name="XrFacialExpressionClientCreateInfoML"> + <member values="XR_TYPE_FACIAL_EXPRESSION_CLIENT_CREATE_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>requestedCount</name></member> + <member optional="true" len="requestedCount">const <type>XrFacialBlendShapeML</type>* <name>requestedFacialBlendShapes</name></member> + </type> + <type category="struct" name="XrFacialExpressionBlendShapePropertiesML"> + <member values="XR_TYPE_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrFacialBlendShapeML</type> <name>requestedFacialBlendShape</name></member> + <member noautovalidity="true"><type>float</type> <name>weight</name></member> + <member noautovalidity="true"><type>XrFacialExpressionBlendShapePropertiesFlagsML</type> <name>flags</name></member> + <member noautovalidity="true"><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrFacialExpressionBlendShapeGetInfoML"> + <member values="XR_TYPE_FACIAL_EXPRESSION_BLEND_SHAPE_GET_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <!-- XR_META_recommended_layer_resolution types --> + <type category="struct" name="XrRecommendedLayerResolutionMETA" returnedonly="true"> + <member values="XR_TYPE_RECOMMENDED_LAYER_RESOLUTION_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrExtent2Di</type> <name>recommendedImageDimensions</name></member> + <member><type>XrBool32</type> <name>isValid</name></member> + </type> + + <type category="struct" name="XrRecommendedLayerResolutionGetInfoMETA"> + <member values="XR_TYPE_RECOMMENDED_LAYER_RESOLUTION_GET_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member>const <type>XrCompositionLayerBaseHeader</type>* <name>layer</name></member> + <member><type>XrTime</type> <name>predictedDisplayTime</name></member> + </type> + + <!-- XR_EXT_user_presence --> + <type category="struct" name="XrSystemUserPresencePropertiesEXT" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_USER_PRESENCE_PROPERTIES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsUserPresence</name></member> + </type> + + <type category="struct" name="XrEventDataUserPresenceChangedEXT" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_USER_PRESENCE_CHANGED_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSession</type> <name>session</name></member> + <member><type>XrBool32</type> <name>isUserPresent</name></member> + </type> + + <!-- XR_EXT_future --> + <type category="struct" name="XrFutureCompletionBaseHeaderEXT"> + <member><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + </type> + + <type category="struct" name="XrFutureCompletionEXT" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_FUTURE_COMPLETION_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + </type> + + <type category="struct" name="XrFutureCancelInfoEXT"> + <member values="XR_TYPE_FUTURE_CANCEL_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrFutureEXT</type> <name>future</name></member> + </type> + + <type category="struct" name="XrFuturePollInfoEXT"> + <member values="XR_TYPE_FUTURE_POLL_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrFutureEXT</type> <name>future</name></member> + </type> + + <type category="struct" name="XrFuturePollResultEXT" returnedonly="true"> + <member values="XR_TYPE_FUTURE_POLL_RESULT_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrFutureStateEXT</type> <name>state</name></member> + </type> + + + + <!-- XR_META_environment_depth --> + <type category="struct" name="XrEnvironmentDepthProviderCreateInfoMETA"> + <member values="XR_TYPE_ENVIRONMENT_DEPTH_PROVIDER_CREATE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrEnvironmentDepthProviderCreateFlagsMETA</type> <name>createFlags</name></member> + </type> + <type category="struct" name="XrEnvironmentDepthSwapchainCreateInfoMETA"> + <member values="XR_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_CREATE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrEnvironmentDepthSwapchainCreateFlagsMETA</type> <name>createFlags</name></member> + </type> + <type category="struct" name="XrEnvironmentDepthSwapchainStateMETA"> + <member values="XR_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_STATE_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>width</name></member> + <member><type>uint32_t</type> <name>height</name></member> + </type> + <type category="struct" name="XrEnvironmentDepthImageAcquireInfoMETA"> + <member values="XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_ACQUIRE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrTime</type> <name>displayTime</name></member> + </type> + <type category="struct" name="XrEnvironmentDepthImageViewMETA"> + <member values="XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_VIEW_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrFovf</type> <name>fov</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrEnvironmentDepthImageMETA"> + <member values="XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>swapchainIndex</name></member> + <member><type>float</type> <name>nearZ</name></member> + <member><type>float</type> <name>farZ</name></member> + <member><type>XrEnvironmentDepthImageViewMETA</type> <name>views</name>[2]</member> + </type> + <type category="struct" name="XrEnvironmentDepthImageTimestampMETA" structextends="XrEnvironmentDepthImageMETA"> + <member values="XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_TIMESTAMP_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>captureTime</name></member> + </type> + <type category="struct" name="XrEnvironmentDepthHandRemovalSetInfoMETA"> + <member values="XR_TYPE_ENVIRONMENT_DEPTH_HAND_REMOVAL_SET_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>enabled</name></member> + </type> + <type category="struct" name="XrSystemEnvironmentDepthPropertiesMETA" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_ENVIRONMENT_DEPTH_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsEnvironmentDepth</name></member> + <member><type>XrBool32</type> <name>supportsHandRemoval</name></member> + </type> + + <!-- XR_KHR_locate_spaces --> + <type category="struct" name="XrSpacesLocateInfoKHR" alias="XrSpacesLocateInfo"/> + <type category="struct" name="XrSpacesLocateInfo"> + <member values="XR_TYPE_SPACES_LOCATE_INFO"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>uint32_t</type> <name>spaceCount</name></member> + <member len="spaceCount">const <type>XrSpace</type>* <name>spaces</name></member> + </type> + + <type category="struct" name="XrSpaceLocationsKHR" alias="XrSpaceLocations"/> + <type category="struct" name="XrSpaceLocations"> + <member values="XR_TYPE_SPACE_LOCATIONS"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>locationCount</name></member> + <member len="locationCount"><type>XrSpaceLocationData</type>* <name>locations</name></member> + </type> + + <type category="struct" name="XrSpaceLocationDataKHR" alias="XrSpaceLocationData"/> + <type category="struct" name="XrSpaceLocationData" returnedonly="true"> + <member><type>XrSpaceLocationFlags</type> <name>locationFlags</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + + <type category="struct" name="XrSpaceVelocitiesKHR" alias="XrSpaceVelocities"/> + <type category="struct" name="XrSpaceVelocities" structextends="XrSpaceLocations"> + <member values="XR_TYPE_SPACE_VELOCITIES"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>velocityCount</name></member> + <member len="velocityCount"><type>XrSpaceVelocityData</type>* <name>velocities</name></member> + </type> + + <type category="struct" name="XrSpaceVelocityDataKHR" alias="XrSpaceVelocityData"/> + <type category="struct" name="XrSpaceVelocityData" returnedonly="true"> + <member><type>XrSpaceVelocityFlags</type> <name>velocityFlags</name></member> + <member><type>XrVector3f</type> <name>linearVelocity</name></member> + <member><type>XrVector3f</type> <name>angularVelocity</name></member> + </type> + + <!-- XR_EXT_spatial_entity --> + <type category="struct" name="XrSpatialCapabilityComponentTypesEXT"> + <member values="XR_TYPE_SPATIAL_CAPABILITY_COMPONENT_TYPES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>componentTypeCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>componentTypeCountOutput</name></member> + <member len="componentTypeCapacityInput" optional="true"><type>XrSpatialComponentTypeEXT</type>* <name>componentTypes</name></member> + </type> + + <type category="struct" name="XrSpatialCapabilityConfigurationBaseHeaderEXT"> + <member noautovalidity="true"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialCapabilityEXT</type> <name>capability</name></member> + <member><type>uint32_t</type> <name>enabledComponentCount</name></member> + <member len="enabledComponentCount">const <type>XrSpatialComponentTypeEXT</type>* <name>enabledComponents</name></member> + </type> + + <type category="struct" name="XrSpatialContextCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_CONTEXT_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>capabilityConfigCount</name></member> + <member len="capabilityConfigCount">const <type>XrSpatialCapabilityConfigurationBaseHeaderEXT</type>* const* <name>capabilityConfigs</name></member> + </type> + + <type category="struct" name="XrCreateSpatialContextCompletionEXT" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_CREATE_SPATIAL_CONTEXT_COMPLETION_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member optional="true"><type>XrSpatialContextEXT</type> <name>spatialContext</name></member> + </type> + + <type category="struct" name="XrSpatialDiscoverySnapshotCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_DISCOVERY_SNAPSHOT_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>componentTypeCount</name></member> + <member optional="true" len="componentTypeCount">const <type>XrSpatialComponentTypeEXT</type>* <name>componentTypes</name></member> + </type> + + <type category="struct" name="XrCreateSpatialDiscoverySnapshotCompletionInfoEXT"> + <member values="XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrFutureEXT</type> <name>future</name></member> + </type> + + <type category="struct" name="XrCreateSpatialDiscoverySnapshotCompletionEXT" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member optional="true"><type>XrSpatialSnapshotEXT</type> <name>snapshot</name></member> + </type> + + <type category="struct" name="XrSpatialComponentDataQueryConditionEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_CONDITION_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>componentTypeCount</name></member> + <member optional="true" len="componentTypeCount">const <type>XrSpatialComponentTypeEXT</type>* <name>componentTypes</name></member> + </type> + + <type category="struct" name="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_RESULT_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>entityIdCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>entityIdCountOutput</name></member> + <member len="entityIdCapacityInput" optional="true"><type>XrSpatialEntityIdEXT</type>* <name>entityIds</name></member> + <member optional="true"><type>uint32_t</type> <name>entityStateCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>entityStateCountOutput</name></member> + <member len="entityStateCapacityInput" optional="true"><type>XrSpatialEntityTrackingStateEXT</type>* <name>entityStates</name></member> + </type> + + <type category="struct" name="XrSpatialBufferEXT"> + <member><type>XrSpatialBufferIdEXT</type> <name>bufferId</name></member> + <member><type>XrSpatialBufferTypeEXT</type> <name>bufferType</name></member> + </type> + + <type category="struct" name="XrSpatialBufferGetInfoEXT"> + <member values="XR_TYPE_SPATIAL_BUFFER_GET_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialBufferIdEXT</type> <name>bufferId</name></member> + </type> + + <type category="struct" name="XrSpatialBounded2DDataEXT"> + <member><type>XrPosef</type> <name>center</name></member> + <member><type>XrExtent2Df</type> <name>extents</name></member> + </type> + + <type category="struct" name="XrSpatialComponentBounded2DListEXT" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_BOUNDED_2D_LIST_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>boundCount</name></member> + <member len="boundCount"><type>XrSpatialBounded2DDataEXT</type>* <name>bounds</name></member> + </type> + + <type category="struct" name="XrSpatialComponentBounded3DListEXT" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_BOUNDED_3D_LIST_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>boundCount</name></member> + <member len="boundCount"><type>XrBoxf</type>* <name>bounds</name></member> + </type> + + <type category="struct" name="XrSpatialComponentParentListEXT" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_PARENT_LIST_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>parentCount</name></member> + <member len="parentCount"><type>XrSpatialEntityIdEXT</type>* <name>parents</name></member> + </type> + + <type category="struct" name="XrSpatialMeshDataEXT"> + <member><type>XrPosef</type> <name>origin</name></member> + <member><type>XrSpatialBufferEXT</type> <name>vertexBuffer</name></member> + <member><type>XrSpatialBufferEXT</type> <name>indexBuffer</name></member> + </type> + + <type category="struct" name="XrSpatialComponentMesh3DListEXT" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_MESH_3D_LIST_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>meshCount</name></member> + <member len="meshCount"><type>XrSpatialMeshDataEXT</type>* <name>meshes</name></member> + </type> + + <type category="struct" name="XrSpatialEntityFromIdCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_ENTITY_FROM_ID_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialEntityIdEXT</type> <name>entityId</name></member> + </type> + + <type category="struct" name="XrSpatialUpdateSnapshotCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_UPDATE_SNAPSHOT_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>entityCount</name></member> + <member len="entityCount">const <type>XrSpatialEntityEXT</type>* <name>entities</name></member> + <member optional="true"><type>uint32_t</type> <name>componentTypeCount</name></member> + <member optional="true" len="componentTypeCount">const <type>XrSpatialComponentTypeEXT</type>* <name>componentTypes</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <type category="struct" name="XrEventDataSpatialDiscoveryRecommendedEXT" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialContextEXT</type> <name>spatialContext</name></member> + </type> + + <type category="struct" name="XrSpatialFilterTrackingStateEXT" structextends="XrSpatialDiscoverySnapshotCreateInfoEXT,XrSpatialComponentDataQueryConditionEXT"> + <member values="XR_TYPE_SPATIAL_FILTER_TRACKING_STATE_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialEntityTrackingStateEXT</type> <name>trackingState</name></member> + </type> + + <!-- XR_EXT_spatial_anchor --> + <type category="struct" name="XrSpatialCapabilityConfigurationAnchorEXT" parentstruct="XrSpatialCapabilityConfigurationBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ANCHOR_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialCapabilityEXT</type> <name>capability</name></member> + <member><type>uint32_t</type> <name>enabledComponentCount</name></member> + <member len="enabledComponentCount">const <type>XrSpatialComponentTypeEXT</type>* <name>enabledComponents</name></member> + </type> + + <type category="struct" name="XrSpatialComponentAnchorListEXT" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_ANCHOR_LIST_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>locationCount</name></member> + <member len="locationCount"><type>XrPosef</type>* <name>locations</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + + <!-- XR_EXT_spatial_persistence --> + <type category="struct" name="XrSpatialPersistenceContextCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_PERSISTENCE_CONTEXT_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialPersistenceScopeEXT</type> <name>scope</name></member> + </type> + + <type category="struct" name="XrCreateSpatialPersistenceContextCompletionEXT" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_CREATE_SPATIAL_PERSISTENCE_CONTEXT_COMPLETION_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>XrSpatialPersistenceContextResultEXT</type> <name>createResult</name></member> + <member><type>XrSpatialPersistenceContextEXT</type> <name>persistenceContext</name></member> + </type> + + <type category="struct" name="XrSpatialContextPersistenceConfigEXT" structextends="XrSpatialContextCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_CONTEXT_PERSISTENCE_CONFIG_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>persistenceContextCount</name></member> + <member len="persistenceContextCount">const <type>XrSpatialPersistenceContextEXT</type>* <name>persistenceContexts</name></member> + </type> + + <type category="struct" name="XrSpatialDiscoveryPersistenceUuidFilterEXT" structextends="XrSpatialDiscoverySnapshotCreateInfoEXT,XrSpatialComponentDataQueryConditionEXT"> + <member values="XR_TYPE_SPATIAL_DISCOVERY_PERSISTENCE_UUID_FILTER_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>persistedUuidCount</name></member> + <member len="persistedUuidCount">const <type>XrUuid</type>* <name>persistedUuids</name></member> + </type> + + <type category="struct" name="XrSpatialPersistenceDataEXT"> + <member><type>XrUuid</type> <name>persistUuid</name></member> + <member><type>XrSpatialPersistenceStateEXT</type> <name>persistState</name></member> + </type> + + <type category="struct" name="XrSpatialComponentPersistenceListEXT" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_PERSISTENCE_LIST_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>persistDataCount</name></member> + <member len="persistDataCount"><type>XrSpatialPersistenceDataEXT</type>* <name>persistData</name></member> + </type> + + <!-- XR_EXT_spatial_persistence_operations --> + <type category="struct" name="XrSpatialEntityPersistInfoEXT"> + <member values="XR_TYPE_SPATIAL_ENTITY_PERSIST_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialContextEXT</type> <name>spatialContext</name></member> + <member><type>XrSpatialEntityIdEXT</type> <name>spatialEntityId</name></member> + </type> + + <type category="struct" name="XrPersistSpatialEntityCompletionEXT" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_PERSIST_SPATIAL_ENTITY_COMPLETION_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>XrSpatialPersistenceContextResultEXT</type> <name>persistResult</name></member> + <member><type>XrUuid</type> <name>persistUuid</name></member> + </type> + + <type category="struct" name="XrSpatialEntityUnpersistInfoEXT"> + <member values="XR_TYPE_SPATIAL_ENTITY_UNPERSIST_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrUuid</type> <name>persistUuid</name></member> + </type> + + <type category="struct" name="XrUnpersistSpatialEntityCompletionEXT" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_UNPERSIST_SPATIAL_ENTITY_COMPLETION_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>XrSpatialPersistenceContextResultEXT</type> <name>unpersistResult</name></member> + </type> + + <!-- XR_EXT_spatial_plane_tracking --> + <type category="struct" name="XrSpatialCapabilityConfigurationPlaneTrackingEXT" parentstruct="XrSpatialCapabilityConfigurationBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_PLANE_TRACKING_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialCapabilityEXT</type> <name>capability</name></member> + <member><type>uint32_t</type> <name>enabledComponentCount</name></member> + <member len="enabledComponentCount">const <type>XrSpatialComponentTypeEXT</type>* <name>enabledComponents</name></member> + </type> + + <type category="struct" name="XrSpatialComponentPlaneAlignmentListEXT" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_PLANE_ALIGNMENT_LIST_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>planeAlignmentCount</name></member> + <member len="planeAlignmentCount"><type>XrSpatialPlaneAlignmentEXT</type>* <name>planeAlignments</name></member> + </type> + + <type category="struct" name="XrSpatialComponentMesh2DListEXT" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_MESH_2D_LIST_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>meshCount</name></member> + <member len="meshCount"><type>XrSpatialMeshDataEXT</type>* <name>meshes</name></member> + </type> + + <type category="struct" name="XrSpatialPolygon2DDataEXT"> + <member><type>XrPosef</type> <name>origin</name></member> + <member><type>XrSpatialBufferEXT</type> <name>vertexBuffer</name></member> + </type> + + <type category="struct" name="XrSpatialComponentPolygon2DListEXT" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_POLYGON_2D_LIST_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>polygonCount</name></member> + <member len="polygonCount"><type>XrSpatialPolygon2DDataEXT</type>* <name>polygons</name></member> + </type> + + <type category="struct" name="XrSpatialComponentPlaneSemanticLabelListEXT" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_PLANE_SEMANTIC_LABEL_LIST_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>semanticLabelCount</name></member> + <member len="semanticLabelCount"><type>XrSpatialPlaneSemanticLabelEXT</type>* <name>semanticLabels</name></member> + </type> + + <!-- XR_EXT_stationary_reference_space --> + <type category="struct" name="XrStationaryReferenceSpaceGenerationIdGetInfoEXT"> + <member values="XR_TYPE_STATIONARY_REFERENCE_SPACE_GENERATION_ID_GET_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrStationaryReferenceSpaceGenerationIdResultEXT"> + <member values="XR_TYPE_STATIONARY_REFERENCE_SPACE_GENERATION_ID_RESULT_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrUuid</type> <name>generationId</name></member> + </type> + + <!-- XR_ANDROID_spatial_discovery_bounds --> + <type category="struct" name="XrSpatialBoundsSpherefANDROID" structextends="XrSpatialDiscoverySnapshotCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_BOUNDS_SPHEREF_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrSpheref</type> <name>sphere</name></member> + </type> + <type category="struct" name="XrSpatialBoundsBoxfANDROID" structextends="XrSpatialDiscoverySnapshotCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_BOUNDS_BOXF_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrBoxf</type> <name>box</name></member> + </type> + <type category="struct" name="XrSpatialBoundsFrustumfANDROID" structextends="XrSpatialDiscoverySnapshotCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_BOUNDS_FRUSTUMF_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrFrustumf</type> <name>frustum</name></member> + </type> + + <!-- XR_ML_system_notifications --> + <type category="struct" name="XrSystemNotificationsSetInfoML"> + <member values="XR_TYPE_SYSTEM_NOTIFICATIONS_SET_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>suppressNotifications</name></member> + </type> + + <!-- XR_BD_spatial_audio_rendering --> + <type category="struct" name="XrSpatialAudioRendererCreateInfoBD"> + <member values="XR_TYPE_SPATIAL_AUDIO_RENDERER_CREATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>framesPerBuffer</name></member> + <member><type>XrAudioSampleRateBD</type> <name>sampleRate</name></member> + </type> + + <type category="struct" name="XrAudioBufferBD"> + <member values="XR_TYPE_AUDIO_BUFFER_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAudioBufferChannelLayoutBD</type> <name>channelLayout</name></member> + <member><type>uint32_t</type> <name>bufferChannels</name></member> + <member><type>uint32_t</type> <name>bufferLength</name></member> + <member len="bufferLength"><type>float</type>* <name>buffer</name></member> + </type> + + <type category="struct" name="XrSoundObjectDirectivityCardioidBD" structextends="XrSoundObjectConfigBD"> + <member values="XR_TYPE_SOUND_OBJECT_DIRECTIVITY_CARDIOID_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>alpha</name></member> + <member><type>float</type> <name>order</name></member> + </type> + + <type category="struct" name="XrSoundObjectShapeSphereBD" structextends="XrSoundObjectConfigBD"> + <member values="XR_TYPE_SOUND_OBJECT_SHAPE_SPHERE_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>radius</name></member> + </type> + + <type category="struct" name="XrSoundObjectDistanceAttenuationBD"> + <member values="XR_TYPE_SOUND_OBJECT_DISTANCE_ATTENUATION_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSoundObjectDistanceAttenuationTypeBD</type> <name>distanceAttenuationType</name></member> + <member><type>float</type> <name>minAttenuationRange</name></member> + <member><type>float</type> <name>maxAttenuationRange</name></member> + <member><type>float</type> <name>referenceDistance</name></member> + <member><type>float</type> <name>rolloffFactor</name></member> + <member optional="true"><type>XrSoundObjectDistanceAttenuationCurveBD</type>* <name>customDistanceAttenuationCurve</name></member> + </type> + + <type category="struct" name="XrAttenuationCurvePointBD"> + <member><type>float</type> <name>distance</name></member> + <member><type>float</type> <name>gain</name></member> + </type> + + <type category="struct" name="XrSoundObjectDistanceAttenuationCurveBD"> + <member values="XR_TYPE_SOUND_OBJECT_DISTANCE_ATTENUATION_CURVE_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>curvePointCount</name></member> + <member len="curvePointCount"><type>XrAttenuationCurvePointBD</type>* <name>curvePoints</name></member> + </type> + + <type category="struct" name="XrSoundObjectConfigBD"> + <member values="XR_TYPE_SOUND_OBJECT_CONFIG_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>enabled</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>float</type> <name>mainVolume</name></member> + <member><type>float</type> <name>reflectionGain</name></member> + <member><type>XrBool32</type> <name>enableDoppler</name></member> + <member>const <type>XrSoundObjectDistanceAttenuationBD</type>* <name>directSoundAttenuation</name></member> + <member>const <type>XrSoundObjectDistanceAttenuationBD</type>* <name>indirectSoundAttenuation</name></member> + </type> + + <type category="struct" name="XrSoundFieldConfigBD"> + <member values="XR_TYPE_SOUND_FIELD_CONFIG_BD"> <type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>enabled</name></member> + <member><type>XrQuaternionf</type> <name>orientation</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>float</type> <name>mainVolume</name></member> + <member><type>float</type> <name>lfeGain</name></member> + </type> + + <type category="struct" name="XrSoundFieldChannelDefinitionSurroundBD" structextends="XrSoundFieldConfigBD"> + <member values="XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_SURROUND_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSoundFieldChannelMaskSurroundBD</type> <name>channelMask</name></member> + </type> + + <type category="struct" name="XrSoundFieldChannelDefinitionAmbixBD" structextends="XrSoundFieldConfigBD"> + <member values="XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_AMBIX_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSoundFieldChannelMaskAmbixBD</type> <name>channelMask</name></member> + </type> + + <type category="struct" name="XrSoundFieldChannelDefinitionFumaBD" structextends="XrSoundFieldConfigBD"> + <member values="XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_FUMA_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSoundFieldChannelMaskFumaBD</type> <name>channelMask</name></member> + </type> + + <type category="struct" name="XrSoundTriangleMeshBD"> + <member values="XR_TYPE_SOUND_TRIANGLE_MESH_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>vertexCount</name></member> + <member len="vertexCount"><type>XrVector3f</type>* <name>vertices</name></member> + <member><type>uint32_t</type> <name>indexCount</name></member> + <member len="indexCount"><type>uint32_t</type>* <name>indices</name></member> + </type> + + <type category="struct" name="XrSoundObstacleConfigBD"> + <member values="XR_TYPE_SOUND_OBSTACLE_CONFIG_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>enabled</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>uint32_t</type> <name>materialCount</name></member> + <member len="materialCount"><type>XrSoundObstacleMaterialBD</type>* <name>materials</name></member> + </type> + + <type category="struct" name="XrSoundObstacleMaterialConfigBD"> + <member values="XR_TYPE_SOUND_OBSTACLE_MATERIAL_CONFIG_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSoundObstacleMaterialTypeBD</type> <name>materialType</name></member> + <member><type>uint32_t</type> <name>bandCount</name></member> + <member len="bandCount"><type>float</type>* <name>bandFrequencies</name></member> + <member len="bandCount"><type>float</type>* <name>bandAbsorptions</name></member> + <member len="bandCount"><type>float</type>* <name>bandScatterings</name></member> + <member len="bandCount"><type>float</type>* <name>bandTransmissions</name></member> + </type> + + <!-- XR_ML_spatial_anchors --> + <type category="struct" name="XrSpatialAnchorsCreateInfoBaseHeaderML"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsCreateInfoFromPoseML" parentstruct="XrSpatialAnchorsCreateInfoBaseHeaderML"> + <member values="XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_POSE_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrPosef</type> <name>poseInBaseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <type category="struct" name="XrCreateSpatialAnchorsCompletionML" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_CREATE_SPATIAL_ANCHORS_COMPLETION_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrResult</type> <name>futureResult</name></member> + <member optional="true"><type>uint32_t</type> <name>spaceCount</name></member> + <member optional="true" len="spaceCount"><type>XrSpace</type>* <name>spaces</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorStateML"> + <member values="XR_TYPE_SPATIAL_ANCHOR_STATE_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrSpatialAnchorConfidenceML</type> <name>confidence</name></member> + </type> + + <!-- XR_ML_spatial_anchors_storage --> + <type category="struct" name="XrSpatialAnchorsCreateStorageInfoML"> + <member values="XR_TYPE_SPATIAL_ANCHORS_CREATE_STORAGE_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsQueryInfoBaseHeaderML"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsQueryInfoRadiusML" parentstruct="XrSpatialAnchorsQueryInfoBaseHeaderML"> + <member values="XR_TYPE_SPATIAL_ANCHORS_QUERY_INFO_RADIUS_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrVector3f</type> <name>center</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>float</type> <name>radius</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsQueryCompletionML" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_ANCHORS_QUERY_COMPLETION_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>XrResult</type> <name>futureResult</name></member> + <member optional="true"><type>uint32_t</type> <name>uuidCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>uuidCountOutput</name></member> + <member optional="true" len="uuidCapacityInput"><type>XrUuidEXT</type>* <name>uuids</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsCreateInfoFromUuidsML" parentstruct="XrSpatialAnchorsCreateInfoBaseHeaderML"> + <member values="XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_UUIDS_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialAnchorsStorageML</type> <name>storage</name></member> + <member><type>uint32_t</type> <name>uuidCount</name></member> + <member len="uuidCount">const <type>XrUuidEXT</type>* <name>uuids</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsPublishInfoML"> + <member values="XR_TYPE_SPATIAL_ANCHORS_PUBLISH_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>anchorCount</name></member> + <member len="anchorCount">const <type>XrSpace</type>* <name>anchors</name></member> + <member><type>uint64_t</type> <name>expiration</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsPublishCompletionML" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_ANCHORS_PUBLISH_COMPLETION_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>uint32_t</type> <name>uuidCount</name></member> + <member len="uuidCount"><type>XrUuidEXT</type>* <name>uuids</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsDeleteInfoML"> + <member values="XR_TYPE_SPATIAL_ANCHORS_DELETE_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>uuidCount</name></member> + <member len="uuidCount">const <type>XrUuidEXT</type>* <name>uuids</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsDeleteCompletionML" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_ANCHORS_DELETE_COMPLETION_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsUpdateExpirationInfoML"> + <member values="XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>uuidCount</name></member> + <member len="uuidCount">const <type>XrUuidEXT</type>* <name>uuids</name></member> + <member><type>uint64_t</type> <name>expiration</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsUpdateExpirationCompletionML" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_COMPLETION_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorCompletionResultML"> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + <member><type>XrResult</type> <name>result</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsPublishCompletionDetailsML" structextends="XrSpatialAnchorsPublishCompletionML"> + <member values="XR_TYPE_SPATIAL_ANCHORS_PUBLISH_COMPLETION_DETAILS_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>resultCount</name></member> + <member len="resultCount"><type>XrSpatialAnchorCompletionResultML</type>* <name>results</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsDeleteCompletionDetailsML" structextends="XrSpatialAnchorsDeleteCompletionML"> + <member values="XR_TYPE_SPATIAL_ANCHORS_DELETE_COMPLETION_DETAILS_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>resultCount</name></member> + <member len="resultCount"><type>XrSpatialAnchorCompletionResultML</type>* <name>results</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorsUpdateExpirationCompletionDetailsML" structextends="XrSpatialAnchorsUpdateExpirationCompletionML"> + <member values="XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_COMPLETION_DETAILS_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>resultCount</name></member> + <member len="resultCount"><type>XrSpatialAnchorCompletionResultML</type>* <name>results</name></member> + </type> + + <!-- XR_ML_world_mesh_detection --> + <type category="struct" name="XrWorldMeshDetectorCreateInfoML"> + <member values="XR_TYPE_WORLD_MESH_DETECTOR_CREATE_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrWorldMeshStateRequestInfoML"> + <member values="XR_TYPE_WORLD_MESH_STATE_REQUEST_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrPosef</type> <name>boundingBoxCenter</name></member> + <member><type>XrExtent3DfEXT</type> <name>boundingBoxExtents</name></member> + </type> + + <type category="struct" name="XrWorldMeshBlockStateML"> + <member values="XR_TYPE_WORLD_MESH_BLOCK_STATE_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + <member><type>XrPosef</type> <name>meshBoundingBoxCenter</name></member> + <member><type>XrExtent3DfEXT</type> <name>meshBoundingBoxExtents</name></member> + <member><type>XrTime</type> <name>lastUpdateTime</name></member> + <member><type>XrWorldMeshBlockStatusML</type> <name>status</name></member> + </type> + + <type category="struct" name="XrWorldMeshStateRequestCompletionML" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_WORLD_MESH_STATE_REQUEST_COMPLETION_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member optional="true"><type>XrTime</type> <name>timestamp</name></member> + <member optional="true"><type>uint32_t</type> <name>meshBlockStateCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>meshBlockStateCountOutput</name></member> + <member optional="true" len="meshBlockStateCapacityInput"><type>XrWorldMeshBlockStateML</type>* <name>meshBlockStates</name></member> + </type> + + <type category="struct" name="XrWorldMeshBufferRecommendedSizeInfoML"> + <member values="XR_TYPE_WORLD_MESH_BUFFER_RECOMMENDED_SIZE_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>maxBlockCount</name></member> + </type> + + <type category="struct" name="XrWorldMeshBufferSizeML"> + <member values="XR_TYPE_WORLD_MESH_BUFFER_SIZE_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>size</name></member> + </type> + + <type category="struct" name="XrWorldMeshBufferML"> + <member values="XR_TYPE_WORLD_MESH_BUFFER_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>bufferSize</name></member> + <member len="bufferSize"><type>void</type>* <name>buffer</name></member> + </type> + + <type category="struct" name="XrWorldMeshBlockRequestML"> + <member values="XR_TYPE_WORLD_MESH_BLOCK_REQUEST_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + <member><type>XrWorldMeshDetectorLodML</type> <name>lod</name></member> + </type> + + <type category="struct" name="XrWorldMeshGetInfoML"> + <member values="XR_TYPE_WORLD_MESH_GET_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrWorldMeshDetectorFlagsML</type> <name>flags</name></member> + <member><type>float</type> <name>fillHoleLength</name></member> + <member><type>float</type> <name>disconnectedComponentArea</name></member> + <member><type>uint32_t</type> <name>blockCount</name></member> + <member len="blockCount"><type>XrWorldMeshBlockRequestML</type>* <name>blocks</name></member> + </type> + + <type category="struct" name="XrWorldMeshBlockML"> + <member values="XR_TYPE_WORLD_MESH_BLOCK_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + <member><type>XrWorldMeshBlockResultML</type> <name>blockResult</name></member> + <member><type>XrWorldMeshDetectorLodML</type> <name>lod</name></member> + <member><type>XrWorldMeshDetectorFlagsML</type> <name>flags</name></member> + <member><type>uint32_t</type> <name>indexCount</name></member> + <member len="indexCount"><type>uint16_t</type>* <name>indexBuffer</name></member> + <member><type>uint32_t</type> <name>vertexCount</name></member> + <member len="vertexCount"><type>XrVector3f</type>* <name>vertexBuffer</name></member> + <member><type>uint32_t</type> <name>normalCount</name></member> + <member len="normalCount"><type>XrVector3f</type>* <name>normalBuffer</name></member> + <member><type>uint32_t</type> <name>confidenceCount</name></member> + <member len="confidenceCount"><type>float</type>* <name>confidenceBuffer</name></member> + </type> + + <type category="struct" name="XrWorldMeshRequestCompletionInfoML"> + <member values="XR_TYPE_WORLD_MESH_REQUEST_COMPLETION_INFO_ML"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>meshSpace</name></member> + <member><type>XrTime</type> <name>meshSpaceLocateTime</name></member> + </type> + + <type category="struct" name="XrWorldMeshRequestCompletionML" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_WORLD_MESH_REQUEST_COMPLETION_ML"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>uint32_t</type> <name>blockCount</name></member> + <member len="blockCount"><type>XrWorldMeshBlockML</type>* <name>blocks</name></member> + </type> + + + <!-- XR_META_passthrough_layer_resumed_event --> + <type category="struct" name="XrEventDataPassthroughLayerResumedMETA" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_PASSTHROUGH_LAYER_RESUMED_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPassthroughLayerFB</type> <name>layer</name></member> + </type> + + <!-- XR_EXT_render_model --> + <type category="struct" name="XrRenderModelCreateInfoEXT"> + <member values="XR_TYPE_RENDER_MODEL_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrRenderModelIdEXT</type> <name>renderModelId</name></member> + <member optional="true"><type>uint32_t</type> <name>gltfExtensionCount</name></member> + <member optional="true" len="gltfExtensionCount,null-terminated">const <type>char</type>* const* <name>gltfExtensions</name></member> + </type> + <type category="struct" name="XrRenderModelPropertiesGetInfoEXT"> + <member values="XR_TYPE_RENDER_MODEL_PROPERTIES_GET_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrRenderModelPropertiesEXT" returnedonly="true"> + <member values="XR_TYPE_RENDER_MODEL_PROPERTIES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrUuidEXT</type> <name>cacheId</name></member> + <member><type>uint32_t</type> <name>animatableNodeCount</name></member> + </type> + <type category="struct" name="XrRenderModelSpaceCreateInfoEXT"> + <member values="XR_TYPE_RENDER_MODEL_SPACE_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrRenderModelEXT</type> <name>renderModel</name></member> + </type> + <type category="struct" name="XrRenderModelAssetCreateInfoEXT"> + <member values="XR_TYPE_RENDER_MODEL_ASSET_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrUuidEXT</type> <name>cacheId</name></member> + </type> + <type category="struct" name="XrRenderModelAssetDataGetInfoEXT"> + <member values="XR_TYPE_RENDER_MODEL_ASSET_DATA_GET_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrRenderModelAssetDataEXT"> + <member values="XR_TYPE_RENDER_MODEL_ASSET_DATA_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>bufferCountOutput</name></member> + <member optional="true" len="bufferCapacityInput"><type>uint8_t</type>* <name>buffer</name></member> + </type> + <type category="struct" name="XrRenderModelAssetPropertiesGetInfoEXT"> + <member values="XR_TYPE_RENDER_MODEL_ASSET_PROPERTIES_GET_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrRenderModelAssetNodePropertiesEXT"> + <member><type>char</type> <name>uniqueName</name>[<enum>XR_MAX_RENDER_MODEL_ASSET_NODE_NAME_SIZE_EXT</enum>]</member> + </type> + <type category="struct" name="XrRenderModelAssetPropertiesEXT"> + <member values="XR_TYPE_RENDER_MODEL_ASSET_PROPERTIES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>nodePropertyCount</name></member> + <member len="nodePropertyCount"><type>XrRenderModelAssetNodePropertiesEXT</type>* <name>nodeProperties</name></member> + </type> + <type category="struct" name="XrRenderModelStateGetInfoEXT"> + <member values="XR_TYPE_RENDER_MODEL_STATE_GET_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>displayTime</name></member> + </type> + <type category="struct" name="XrRenderModelNodeStateEXT"> + <member><type>XrPosef</type> <name>nodePose</name></member> + <member><type>XrBool32</type> <name>isVisible</name></member> + </type> + <type category="struct" name="XrRenderModelStateEXT"> + <member values="XR_TYPE_RENDER_MODEL_STATE_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>nodeStateCount</name></member> + <member optional="true" len="nodeStateCount"><type>XrRenderModelNodeStateEXT</type>* <name>nodeStates</name></member> + </type> + + <!-- XR_EXT_interaction_render_model --> + <type category="struct" name="XrInteractionRenderModelIdsEnumerateInfoEXT"> + <member values="XR_TYPE_INTERACTION_RENDER_MODEL_IDS_ENUMERATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrInteractionRenderModelSubactionPathInfoEXT"> + <member values="XR_TYPE_INTERACTION_RENDER_MODEL_SUBACTION_PATH_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrInteractionRenderModelTopLevelUserPathGetInfoEXT"> + <member values="XR_TYPE_INTERACTION_RENDER_MODEL_TOP_LEVEL_USER_PATH_GET_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>topLevelUserPathCount</name></member> + <member len="topLevelUserPathCount">const <type>XrPath</type>* <name>topLevelUserPaths</name></member> + </type> + <type category="struct" name="XrEventDataInteractionRenderModelsChangedEXT" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_INTERACTION_RENDER_MODELS_CHANGED_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <!-- XR_BD_spatial_sensing --> + <type category="struct" name="XrSystemSpatialSensingPropertiesBD" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_SPATIAL_SENSING_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSpatialSensing</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentGetInfoBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_COMPONENT_GET_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialEntityIdBD</type> <name>entityId</name></member> + <member><type>XrSpatialEntityComponentTypeBD</type> <name>componentType</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentDataBaseHeaderBD"> + <member><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrSpatialEntityLocationGetInfoBD" structextends="XrSpatialEntityComponentGetInfoBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_LOCATION_GET_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentDataLocationBD" structextends="XrSpatialEntityComponentDataBaseHeaderBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_LOCATION_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrSpaceLocation</type> <name>location</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentDataSemanticBD" structextends="XrSpatialEntityComponentDataBaseHeaderBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_SEMANTIC_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>labelCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>labelCountOutput</name></member> + <member optional="true" len="labelCapacityInput"><type>XrSemanticLabelBD</type>* <name>labels</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentDataBoundingBox2DBD" structextends="XrSpatialEntityComponentDataBaseHeaderBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_BOUNDING_BOX_2D_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrRect2Df</type> <name>boundingBox2D</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentDataPolygonBD" structextends="XrSpatialEntityComponentDataBaseHeaderBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_POLYGON_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCountOutput</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector2f</type>* <name>vertices</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentDataBoundingBox3DBD" structextends="XrSpatialEntityComponentDataBaseHeaderBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_BOUNDING_BOX_3D_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBoxf</type> <name>boundingBox3D</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentDataTriangleMeshBD" structextends="XrSpatialEntityComponentDataBaseHeaderBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_TRIANGLE_MESH_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCountOutput</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector3f</type>* <name>vertices</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>indexCountOutput</name></member> + <member optional="true" len="indexCapacityInput"><type>uint16_t</type>* <name>indices</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentDataSphereBD" structextends="XrSpatialEntityComponentDataBaseHeaderBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_SPHERE_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrSpheref</type> <name>sphere</name></member> + </type> + + <type category="struct" name="XrSenseDataProviderCreateInfoBD"> + <member values="XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSenseDataProviderTypeBD</type> <name>providerType</name></member> + </type> + + <type category="struct" name="XrSenseDataProviderStartInfoBD"> + <member values="XR_TYPE_SENSE_DATA_PROVIDER_START_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrEventDataSenseDataProviderStateChangedBD" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SENSE_DATA_PROVIDER_STATE_CHANGED_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSenseDataProviderBD</type> <name>provider</name></member> + <member><type>XrSenseDataProviderStateBD</type> <name>newState</name></member> + </type> + + <type category="struct" name="XrEventDataSenseDataUpdatedBD" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SENSE_DATA_UPDATED_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSenseDataProviderBD</type> <name>provider</name></member> + </type> + + <type category="struct" name="XrSenseDataQueryInfoBD"> + <member values="XR_TYPE_SENSE_DATA_QUERY_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrSenseDataFilterUuidBD" structextends="XrSenseDataQueryInfoBD"> + <member values="XR_TYPE_SENSE_DATA_FILTER_UUID_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>uuidCount</name></member> + <member len="uuidCount">const <type>XrUuidEXT</type>* <name>uuids</name></member> + </type> + + <type category="struct" name="XrSenseDataFilterSemanticBD" structextends="XrSenseDataQueryInfoBD"> + <member values="XR_TYPE_SENSE_DATA_FILTER_SEMANTIC_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>labelCount</name></member> + <member len="labelCount">const <type>XrSemanticLabelBD</type>* <name>labels</name></member> + </type> + + <type category="struct" name="XrSenseDataQueryCompletionBD" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_SENSE_DATA_QUERY_COMPLETION_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>XrSenseDataSnapshotBD</type> <name>snapshot</name></member> + </type> + + <type category="struct" name="XrQueriedSenseDataGetInfoBD"> + <member values="XR_TYPE_QUERIED_SENSE_DATA_GET_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrQueriedSenseDataBD"> + <member values="XR_TYPE_QUERIED_SENSE_DATA_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>stateCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>stateCountOutput</name></member> + <member optional="true" len="stateCapacityInput"><type>XrSpatialEntityStateBD</type>* <name>states</name></member> + </type> + + <type category="struct" name="XrSpatialEntityStateBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_STATE_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrSpatialEntityIdBD</type> <name>entityId</name></member> + <member><type>XrTime</type> <name>lastUpdateTime</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + </type> + + <type category="struct" name="XrSpatialEntityAnchorCreateInfoBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_ANCHOR_CREATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSenseDataSnapshotBD</type> <name>snapshot</name></member> + <member><type>XrSpatialEntityIdBD</type> <name>entityId</name></member> + </type> + + <type category="struct" name="XrAnchorSpaceCreateInfoBD"> + <member values="XR_TYPE_ANCHOR_SPACE_CREATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAnchorBD</type> <name>anchor</name></member> + <member><type>XrPosef</type> <name>poseInAnchorSpace</name></member> + </type> + + <!-- XR_BD_spatial_anchor --> + <type category="struct" name="XrSystemSpatialAnchorPropertiesBD" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_SPATIAL_ANCHOR_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSpatialAnchor</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorCreateInfoBD"> + <member values="XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorCreateCompletionBD" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_ANCHOR_CREATE_COMPLETION_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + <member><type>XrAnchorBD</type> <name>anchor</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorPersistInfoBD"> + <member values="XR_TYPE_SPATIAL_ANCHOR_PERSIST_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPersistenceLocationBD</type> <name>location</name></member> + <member><type>XrAnchorBD</type> <name>anchor</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorUnpersistInfoBD"> + <member values="XR_TYPE_SPATIAL_ANCHOR_UNPERSIST_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrPersistenceLocationBD</type> <name>location</name></member> + <member><type>XrAnchorBD</type> <name>anchor</name></member> + </type> + + <!-- XR_BD_spatial_anchor_sharing --> + <type category="struct" name="XrSystemSpatialAnchorSharingPropertiesBD" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_SPATIAL_ANCHOR_SHARING_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSpatialAnchorSharing</name></member> + </type> + + <type category="struct" name="XrSpatialAnchorShareInfoBD"> + <member values="XR_TYPE_SPATIAL_ANCHOR_SHARE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrAnchorBD</type> <name>anchor</name></member> + </type> + + <type category="struct" name="XrSharedSpatialAnchorDownloadInfoBD"> + <member values="XR_TYPE_SHARED_SPATIAL_ANCHOR_DOWNLOAD_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrUuidEXT</type> <name>uuid</name></member> + </type> + + <!-- XR_BD_spatial_mesh --> + <type category="struct" name="XrSystemSpatialMeshPropertiesBD" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_SPATIAL_MESH_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSpatialMesh</name></member> + </type> + + <type category="struct" name="XrSenseDataProviderCreateInfoSpatialMeshBD" structextends="XrSenseDataProviderCreateInfoBD"> + <member values="XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_SPATIAL_MESH_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>XrSpatialMeshConfigFlagsBD</type> <name>configFlags</name></member> + <member><type>XrSpatialMeshLodBD</type> <name>lod</name></member> + </type> + + <!-- XR_BD_spatial_light_estimation --> + <type category="struct" name="XrSystemLightEstimationPropertiesBD" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_LIGHT_ESTIMATION_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsLightEstimation</name></member> + <member><type>XrBool32</type> <name>supportsEnvironmentTexture</name></member> + <member><type>XrBool32</type> <name>supportsSphericalHarmonics</name></member> + </type> + + <type category="struct" name="XrSenseDataProviderCreateInfoLightEstimationBD" structextends="XrSenseDataProviderCreateInfoBD"> + <member values="XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_LIGHT_ESTIMATION_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrLightEstimationCreateFlagsBD</type> <name>createFlags</name></member> + </type> + + <type category="struct" name="XrEnvironmentTextureCreateConfigInfoBD" structextends="XrSenseDataProviderCreateInfoBD"> + <member values="XR_TYPE_ENVIRONMENT_TEXTURE_CREATE_CONFIG_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrEnvironmentTexturePixelFormatBD</type> <name>pixelFormat</name></member> + <member><type>XrEnvironmentTextureResolutionBD</type> <name>resolution</name></member> + <member><type>XrEnvironmentTextureTransferTypeBD</type> <name>transferType</name></member> + </type> + + <type category="struct" name="XrLightEstimationDataEnvironmentTextureRawBD" structextends="XrSpatialEntityComponentDataLightEstimationBD"> + <member values="XR_TYPE_LIGHT_ESTIMATION_DATA_ENVIRONMENT_TEXTURE_RAW_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrEnvironmentTexturePixelFormatBD</type> <name>pixelFormat</name></member> + <member><type>uint32_t</type> <name>cubemapFaceBufferSize</name></member> + <member len="cubemapFaceBufferSize"><type>uint8_t</type>* <name>rightCubemapFaceBuffer</name></member> + <member len="cubemapFaceBufferSize"><type>uint8_t</type>* <name>leftCubemapFaceBuffer</name></member> + <member len="cubemapFaceBufferSize"><type>uint8_t</type>* <name>topCubemapFaceBuffer</name></member> + <member len="cubemapFaceBufferSize"><type>uint8_t</type>* <name>bottomCubemapFaceBuffer</name></member> + <member len="cubemapFaceBufferSize"><type>uint8_t</type>* <name>frontCubemapFaceBuffer</name></member> + <member len="cubemapFaceBufferSize"><type>uint8_t</type>* <name>backCubemapFaceBuffer</name></member> + </type> + + <type category="struct" name="XrLightEstimationDataSphericalHarmonicsBD" structextends="XrSpatialEntityComponentDataLightEstimationBD"> + <member values="XR_TYPE_LIGHT_ESTIMATION_DATA_SPHERICAL_HARMONICS_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSphericalHarmonicsKindBD</type> <name>kind</name></member> + <member optional="true"><type>uint32_t</type> <name>coefficientCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>coefficientCountOutput</name></member> + <member optional="true" len="coefficientCapacityInput"> <type>float</type>* <name>coefficients</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentDataLightEstimationBD" structextends="XrSpatialEntityComponentDataBaseHeaderBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_LIGHT_ESTIMATION_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>isValid</name></member> + </type> + + + <!-- XR_BD_spatial_scene --> + <type category="struct" name="XrSystemSpatialScenePropertiesBD" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_SPATIAL_SCENE_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSpatialScene</name></member> + </type> + + <type category="struct" name="XrSceneCaptureInfoBD"> + <member values="XR_TYPE_SCENE_CAPTURE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <!-- XR_BD_spatial_plane --> + <type category="struct" name="XrSystemSpatialPlanePropertiesBD" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_SPATIAL_PLANE_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSpatialPlane</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentDataPlaneOrientationBD" structextends="XrSpatialEntityComponentDataBaseHeaderBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_PLANE_ORIENTATION_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrPlaneOrientationBD</type> <name>orientation</name></member> + </type> + + <type category="struct" name="XrSenseDataFilterPlaneOrientationBD" structextends="XrSenseDataQueryInfoBD"> + <member values="XR_TYPE_SENSE_DATA_FILTER_PLANE_ORIENTATION_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>orientationCount</name></member> + <member len="orientationCount"><type>XrPlaneOrientationBD</type>* <name>orientations</name></member> + </type> + + <!-- XR_BD_dynamic_object_tracking --> + <type category="struct" name="XrSystemDynamicObjectTrackingPropertiesBD" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_DYNAMIC_OBJECT_TRACKING_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsDynamicObjectTracking</name></member> + </type> + + <type category="struct" name="XrSenseDataProviderCreateInfoDynamicObjectBD" structextends="XrSenseDataProviderCreateInfoBD"> + <member values="XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_DYNAMIC_OBJECT_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>trackingTypeCount</name></member> + <member len="trackingTypeCount">const <type>XrDynamicObjectTypeBD</type>* <name>trackingTypes</name></member> + </type> + + <type category="struct" name="XrSpatialEntityComponentDataDynamicObjectBD" structextends="XrSpatialEntityComponentDataBaseHeaderBD"> + <member values="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_DYNAMIC_OBJECT_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrDynamicObjectDataBD</type> <name>data</name></member> + </type> + + <type category="struct" name="XrDynamicObjectDataBD"> + <member values="XR_TYPE_DYNAMIC_OBJECT_DATA_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrDynamicObjectTypeBD</type> <name>objectType</name></member> + </type> + + <type category="struct" name="XrSenseDataFilterDynamicObjectTypeBD" structextends="XrSenseDataQueryInfoBD"> + <member values="XR_TYPE_SENSE_DATA_FILTER_DYNAMIC_OBJECT_TYPE_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>typeCount</name></member> + <member len="typeCount">const <type>XrDynamicObjectTypeBD</type>* <name>types</name></member> + </type> + + + <!-- XR_BD_dynamic_object_keyboard --> + <type category="struct" name="XrSystemDynamicObjectKeyboardPropertiesBD" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_DYNAMIC_OBJECT_KEYBOARD_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsDynamicObjectKeyboard</name></member> + </type> + + <!-- XR_BD_dynamic_object_mouse --> + <type category="struct" name="XrSystemDynamicObjectMousePropertiesBD" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_DYNAMIC_OBJECT_MOUSE_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsDynamicObjectMouse</name></member> + </type> + + <!-- XR_META_simultaneous_hands_and_controllers --> + <type category="struct" name="XrSystemSimultaneousHandsAndControllersPropertiesMETA" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_SIMULTANEOUS_HANDS_AND_CONTROLLERS_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsSimultaneousHandsAndControllers</name></member> + </type> + <type category="struct" name="XrSimultaneousHandsAndControllersTrackingResumeInfoMETA"> + <member values="XR_TYPE_SIMULTANEOUS_HANDS_AND_CONTROLLERS_TRACKING_RESUME_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrSimultaneousHandsAndControllersTrackingPauseInfoMETA"> + <member values="XR_TYPE_SIMULTANEOUS_HANDS_AND_CONTROLLERS_TRACKING_PAUSE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <!-- XR_EXT_loader_init_properties --> + <type category="struct" name="XrLoaderInitInfoPropertiesEXT" parentstruct="XrLoaderInitInfoBaseHeaderKHR" structextends="XrLoaderInitInfoBaseHeaderKHR"> + <member values="XR_TYPE_LOADER_INIT_INFO_PROPERTIES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>propertyValueCount</name></member> + <member len="propertyValueCount">const <type>XrLoaderInitPropertyValueEXT</type>* <name>propertyValues</name></member> + </type> + + <type category="struct" name="XrLoaderInitPropertyValueEXT"> + <member len="null-terminated">const <type>char</type>* <name>name</name></member> + <member len="null-terminated">const <type>char</type>* <name>value</name></member> + </type> + + <!-- XR_ANDROID_spatial_discovery_raycast --> + <type category="struct" name="XrSpatialCapabilityConfigurationDepthRaycastANDROID" parentstruct="XrSpatialCapabilityConfigurationBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_DEPTH_RAYCAST_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialCapabilityEXT</type> <name>capability</name></member> + <member><type>uint32_t</type> <name>enabledComponentCount</name></member> + <member len="enabledComponentCount">const <type>XrSpatialComponentTypeEXT</type>* <name>enabledComponents</name></member> + </type> + + <type category="struct" name="XrSpatialRaycastInfoANDROID" structextends="XrSpatialDiscoverySnapshotCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_RAYCAST_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrVector3f</type> <name>origin</name></member> + <member><type>XrVector3f</type> <name>direction</name></member> + <member optional="true"><type>float</type> <name>maxDistance</name></member> + </type> + + <type category="struct" name="XrSpatialRaycastResultDataANDROID"> + <member><type>XrPosef</type> <name>hitPose</name></member> + <member><type>float</type> <name>distanceSquared</name></member> + </type> + + <type category="struct" name="XrSpatialComponentRaycastResultListANDROID" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_RAYCAST_RESULT_LIST_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>raycastResultCount</name></member> + <member len="raycastResultCount"><type>XrSpatialRaycastResultDataANDROID</type>* <name>raycastResults</name></member> + </type> + + <type category="struct" name="XrSpatialRaycastSnapshotCreateInfoANDROID"> + <member values="XR_TYPE_SPATIAL_RAYCAST_SNAPSHOT_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>componentTypeCount</name></member> + <member optional="true" len="componentTypeCount">const <type>XrSpatialComponentTypeEXT</type>* <name>componentTypes</name></member> + <member>const <type>XrSpatialRaycastInfoANDROID</type>* <name>raycastInfo</name></member> + </type> + + <!-- XR_EXT_spatial_marker_tracking --> + <type category="struct" name="XrSpatialCapabilityConfigurationArucoMarkerEXT" parentstruct="XrSpatialCapabilityConfigurationBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ARUCO_MARKER_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialCapabilityEXT</type> <name>capability</name></member> + <member><type>uint32_t</type> <name>enabledComponentCount</name></member> + <member len="enabledComponentCount">const <type>XrSpatialComponentTypeEXT</type>* <name>enabledComponents</name></member> + <member><type>XrSpatialMarkerArucoDictEXT</type> <name>arUcoDict</name></member> + </type> + + <type category="struct" name="XrSpatialCapabilityConfigurationAprilTagEXT" parentstruct="XrSpatialCapabilityConfigurationBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_APRIL_TAG_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialCapabilityEXT</type> <name>capability</name></member> + <member><type>uint32_t</type> <name>enabledComponentCount</name></member> + <member len="enabledComponentCount">const <type>XrSpatialComponentTypeEXT</type>* <name>enabledComponents</name></member> + <member><type>XrSpatialMarkerAprilTagDictEXT</type> <name>aprilDict</name></member> + </type> + + <type category="struct" name="XrSpatialCapabilityConfigurationQrCodeEXT" parentstruct="XrSpatialCapabilityConfigurationBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_QR_CODE_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialCapabilityEXT</type> <name>capability</name></member> + <member><type>uint32_t</type> <name>enabledComponentCount</name></member> + <member len="enabledComponentCount">const <type>XrSpatialComponentTypeEXT</type>* <name>enabledComponents</name></member> + </type> + + <type category="struct" name="XrSpatialCapabilityConfigurationMicroQrCodeEXT" parentstruct="XrSpatialCapabilityConfigurationBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_MICRO_QR_CODE_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialCapabilityEXT</type> <name>capability</name></member> + <member><type>uint32_t</type> <name>enabledComponentCount</name></member> + <member len="enabledComponentCount">const <type>XrSpatialComponentTypeEXT</type>* <name>enabledComponents</name></member> + </type> + + <type category="struct" name="XrSpatialMarkerSizeEXT" structextends="XrSpatialCapabilityConfigurationArucoMarkerEXT,XrSpatialCapabilityConfigurationAprilTagEXT,XrSpatialCapabilityConfigurationQrCodeEXT,XrSpatialCapabilityConfigurationMicroQrCodeEXT"> + <member values="XR_TYPE_SPATIAL_MARKER_SIZE_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>markerSideLength</name></member> + </type> + + <type category="struct" name="XrSpatialMarkerStaticOptimizationEXT" structextends="XrSpatialCapabilityConfigurationArucoMarkerEXT,XrSpatialCapabilityConfigurationAprilTagEXT,XrSpatialCapabilityConfigurationQrCodeEXT,XrSpatialCapabilityConfigurationMicroQrCodeEXT"> + <member values="XR_TYPE_SPATIAL_MARKER_STATIC_OPTIMIZATION_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>optimizeForStaticMarker</name></member> + </type> + + <type category="struct" name="XrSpatialMarkerDataEXT"> + <member><type>XrSpatialCapabilityEXT</type> <name>capability</name></member> + <member><type>uint32_t</type> <name>markerId</name></member> + <member><type>XrSpatialBufferEXT</type> <name>data</name></member> + </type> + + <type category="struct" name="XrSpatialComponentMarkerListEXT" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_MARKER_LIST_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>markerCount</name></member> + <member len="markerCount"><type>XrSpatialMarkerDataEXT</type>* <name>markers</name></member> + </type> + + <!-- XR_META_tile_properties_hint --> + <type name="XrExtent3DiMETA" category="struct"> + <member><type>int32_t</type> <name>width</name></member> + <member><type>int32_t</type> <name>height</name></member> + <member><type>int32_t</type> <name>depth</name></member> + </type> + <type name="XrTilePropertiesMETA" category="struct"> + <member values="XR_TYPE_TILE_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrExtent3DiMETA</type> <name>tileDimensions</name></member> + <member><type>XrExtent2Di</type> <name>apronDimensions</name></member> + <member><type>XrOffset2Di</type> <name>origin</name></member> + </type> + <type name="XrTilePropertiesHintMETA" category="struct"> + <member values="XR_TYPE_TILE_PROPERTIES_HINT_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>propertiesCount</name></member> + <member len="propertiesCount">const <type>XrTilePropertiesMETA</type>* <name>properties</name></member> + </type> + + <!-- XR_BD_facial_simulation --> + <type category="struct" name="XrSystemFacialSimulationPropertiesBD" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_FACIAL_SIMULATION_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsFaceTracking</name></member> + </type> + + <type category="struct" name="XrFaceTrackerCreateInfoBD"> + <member values="XR_TYPE_FACE_TRACKER_CREATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrFacialSimulationModeBD</type> <name>mode</name></member> + </type> + + <type category="struct" name="XrFacialSimulationDataGetInfoBD"> + <member values="XR_TYPE_FACIAL_SIMULATION_DATA_GET_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <type category="struct" name="XrFacialSimulationDataBD"> + <member values="XR_TYPE_FACIAL_SIMULATION_DATA_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>faceExpressionWeightCount</name></member> + <member len="faceExpressionWeightCount"><type>float</type>* <name>faceExpressionWeights</name></member> + <member><type>XrBool32</type> <name>isUpperFaceDataValid</name></member> + <member><type>XrBool32</type> <name>isLowerFaceDataValid</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <type category="struct" name="XrLipExpressionDataBD" structextends="XrFacialSimulationDataBD"> + <member values="XR_TYPE_LIP_EXPRESSION_DATA_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>lipsyncExpressionWeightCount</name></member> + <member len="lipsyncExpressionWeightCount"><type>float</type>* <name>lipsyncExpressionWeights</name></member> + </type> + + <!-- XR_ANDROID_geospatial --> + <type name="XrGeospatialTrackerStateANDROID" category="enum"/> + <type name="XrGeospatialPoseFlagBitsANDROID" category="enum"/> + <type name="XrVPSAvailabilityANDROID" category="enum"/> + + <type category="struct" name="XrSystemGeospatialPropertiesANDROID" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_GEOSPATIAL_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsGeospatial</name></member> + </type> + <type category="struct" name="XrGeospatialTrackerCreateInfoANDROID"> + <member values="XR_TYPE_GEOSPATIAL_TRACKER_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrEventDataGeospatialTrackerStateChangedANDROID" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_GEOSPATIAL_TRACKER_STATE_CHANGED_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrGeospatialTrackerANDROID</type> <name>geospatialTracker</name></member> + <member><type>XrGeospatialTrackerStateANDROID</type> <name>state</name></member> + <member><type>XrResult</type> <name>initializationResult</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrGeospatialPoseANDROID"> + <member><type>XrQuaternionf</type> <name>eastUpSouthOrientation</name></member> + <member><type>double</type> <name>latitude</name></member> + <member><type>double</type> <name>longitude</name></member> + <member><type>double</type> <name>altitude</name></member> + </type> + <type category="struct" name="XrGeospatialPoseFromPoseLocateInfoANDROID"> + <member values="XR_TYPE_GEOSPATIAL_POSE_FROM_POSE_LOCATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrGeospatialPoseResultANDROID" returnedonly="true"> + <member values="XR_TYPE_GEOSPATIAL_POSE_RESULT_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrGeospatialPoseFlagsANDROID</type> <name>poseFlags</name></member> + <member><type>XrGeospatialPoseANDROID</type> <name>geospatialPose</name></member> + <member><type>double</type> <name>horizontalAccuracy</name></member> + <member><type>double</type> <name>verticalAccuracy</name></member> + <member><type>double</type> <name>orientationYawAccuracy</name></member> + </type> + <type category="struct" name="XrGeospatialPoseLocateInfoANDROID"> + <member values="XR_TYPE_GEOSPATIAL_POSE_LOCATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrGeospatialPoseANDROID</type> <name>geospatialPose</name></member> + </type> + <type category="struct" name="XrVPSAvailabilityCheckCompletionANDROID" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_VPS_AVAILABILITY_CHECK_COMPLETION_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>XrVPSAvailabilityANDROID</type> <name>availability</name></member> + </type> + + <!-- XR_ANDROID_geospatial_anchor --> + <type name="XrSurfaceAnchorTypeANDROID" category="enum"/> + <type category="struct" name="XrSystemGeospatialAnchorPropertiesANDROID" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_GEOSPATIAL_ANCHOR_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>maxSurfaceAnchorCount</name></member> + </type> + <type category="struct" name="XrGeospatialTrackerAnchorTrackingInfoANDROID" structextends="XrGeospatialTrackerCreateInfoANDROID"> + <member values="XR_TYPE_GEOSPATIAL_TRACKER_ANCHOR_TRACKING_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>shouldTrackPlanes</name></member> + </type> + <type category="struct" name="XrGeospatialAnchorCreateInfoANDROID"> + <member values="XR_TYPE_GEOSPATIAL_ANCHOR_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrGeospatialTrackerANDROID</type> <name>geospatialTracker</name></member> + <member><type>XrGeospatialPoseANDROID</type> <name>geospatialPose</name></member> + </type> + <type category="struct" name="XrSurfaceAnchorCreateInfoANDROID"> + <member values="XR_TYPE_SURFACE_ANCHOR_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrGeospatialTrackerANDROID</type> <name>geospatialTracker</name></member> + <member><type>XrSurfaceAnchorTypeANDROID</type> <name>surfaceAnchorType</name></member> + <member><type>XrQuaternionf</type> <name>eastUpSouthOrientation</name></member> + <member><type>double</type> <name>latitude</name></member> + <member><type>double</type> <name>longitude</name></member> + <member><type>double</type> <name>altitudeRelativeToSurface</name></member> + </type> + <type category="struct" name="XrSurfaceAnchorCreateCompletionANDROID" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_SURFACE_ANCHOR_CREATE_COMPLETION_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>XrSpatialEntityIdEXT</type> <name>anchorEntityId</name></member> + </type> + + <!-- XR_ANDROID_trackables_image --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrTrackableImageDatabaseANDROID</name>)</type> + + <type name="XrTrackableImageFormatANDROID" category="enum"/> + <type name="XrTrackableImageTrackingModeANDROID" category="enum"/> + + <type category="struct" name="XrSystemImageTrackingPropertiesANDROID" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_IMAGE_TRACKING_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsImageTracking</name></member> + <member><type>XrBool32</type> <name>supportsPhysicalSizeEstimation</name></member> + <member><type>uint32_t</type> <name>maxTrackedImageCount</name></member> + <member><type>uint32_t</type> <name>maxLoadedImageCount</name></member> + </type> + + <type category="struct" name="XrTrackableImageDatabaseEntryANDROID"> + <member values="XR_TYPE_TRACKABLE_IMAGE_DATABASE_ENTRY_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTrackableImageTrackingModeANDROID</type> <name>trackingMode</name></member> + <member optional="true"><type>float</type> <name>physicalWidth</name></member> + <member><type>uint32_t</type> <name>imageWidth</name></member> + <member><type>uint32_t</type> <name>imageHeight</name></member> + <member><type>XrTrackableImageFormatANDROID</type> <name>format</name></member> + <member><type>uint32_t</type> <name>bufferSize</name></member> + <member len="bufferSize">const <type>uint8_t</type>* <name>buffer</name></member> + </type> + + <type category="struct" name="XrTrackableImageDatabaseCreateInfoANDROID"> + <member values="XR_TYPE_TRACKABLE_IMAGE_DATABASE_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>entryCount</name></member> + <member len="entryCount">const <type>XrTrackableImageDatabaseEntryANDROID</type>* <name>entries</name></member> + </type> + + <type category="struct" name="XrCreateTrackableImageDatabaseCompletionANDROID" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_CREATE_TRACKABLE_IMAGE_DATABASE_COMPLETION_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>XrTrackableImageDatabaseANDROID</type> <name>database</name></member> + </type> + + <type category="struct" name="XrTrackableImageConfigurationANDROID"> + <member values="XR_TYPE_TRACKABLE_IMAGE_CONFIGURATION_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>databaseCount</name></member> + <member len="databaseCount">const <type>XrTrackableImageDatabaseANDROID</type>* <name>databases</name></member> + </type> + + <type category="struct" name="XrTrackableImageANDROID"> + <member values="XR_TYPE_TRACKABLE_IMAGE_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTrackingStateANDROID</type> <name>trackingState</name></member> + <member><type>XrTime</type> <name>lastUpdatedTime</name></member> + <member><type>XrTrackableImageDatabaseANDROID</type> <name>database</name></member> + <member><type>uint32_t</type> <name>databaseEntryIndex</name></member> + <member><type>XrPosef</type> <name>centerPose</name></member> + <member><type>XrExtent2Df</type> <name>extents</name></member> + </type> + + <type category="struct" name="XrEventDataImageTrackingLostANDROID" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_IMAGE_TRACKING_LOST_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + + <!-- XR_ANDROID_spatial_object_tracking --> + <type category="struct" name="XrSpatialCapabilityConfigurationObjectTrackingANDROID" parentstruct="XrSpatialCapabilityConfigurationBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_OBJECT_TRACKING_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialCapabilityEXT</type> <name>capability</name></member> + <member><type>uint32_t</type> <name>enabledComponentCount</name></member> + <member len="enabledComponentCount">const <type>XrSpatialComponentTypeEXT</type>* <name>enabledComponents</name></member> + <member><type>uint32_t</type> <name>activeSemanticLabelCount</name></member> + <member len="activeSemanticLabelCount">const <type>XrSpatialObjectSemanticLabelANDROID</type>* <name>activeSemanticLabels</name></member> + </type> + + <type category="struct" name="XrSpatialComponentObjectSemanticLabelListANDROID" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_OBJECT_SEMANTIC_LABEL_LIST_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>semanticLabelCount</name></member> + <member len="semanticLabelCount"><type>XrSpatialObjectSemanticLabelANDROID</type>* <name>semanticLabels</name></member> + </type> + + <!-- XR_ANDROID_spatial_entity_bound_anchor --> + <type category="struct" name="XrSpatialAnchorParentANDROID" structextends="XrSpatialAnchorCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_ANCHOR_PARENT_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialEntityIdEXT</type> <name>parentId</name></member> + </type> + + <!-- XR_ANDROID_spatial_anchor_space --> + <type category="struct" name="XrSpatialAnchorSpaceFromIdCreateInfoANDROID"> + <member values="XR_TYPE_SPATIAL_ANCHOR_SPACE_FROM_ID_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialEntityIdEXT</type> <name>anchorEntityId</name></member> + </type> + + <!-- XR_ANDROID_spatial_component_subsumed_by --> + <type category="struct" name="XrSpatialDiscoveryUniqueEntitiesFilterANDROID" structextends="XrSpatialDiscoverySnapshotCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_DISCOVERY_UNIQUE_ENTITIES_FILTER_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrSpatialComponentSubsumedByListANDROID" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_SUBSUMED_BY_LIST_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>subsumedUniqueIdCount</name></member> + <member len="subsumedUniqueIdCount"><type>XrSpatialEntityIdEXT</type>* <name>subsumedUniqueIds</name></member> + </type> + + <!-- XR_EXT_view_configuration_views_change --> + <type category="struct" name="XrEventDataViewConfigurationViewsChangedEXT" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_VIEW_CONFIGURATION_VIEWS_CHANGED_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSystemId</type> <name>systemId</name></member> + <member><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></member> + </type> + + <!-- XR_EXT_interaction_profile_battery_state_display --> + <type bitvalues="XrBatteryStateDisplayStateFlagBitsEXT" category="bitmask">typedef <type>XrFlags64</type> <name>XrBatteryStateDisplayStateFlagsEXT</name>;</type> + <type name="XrBatteryStateDisplayStateFlagBitsEXT" category="enum"/> + + <type category="struct" name="XrBatteryStateDisplayEXT" structextends="XrInteractionProfileState"> + <member values="XR_TYPE_BATTERY_STATE_DISPLAY_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBatteryStateDisplayStateFlagsEXT</type> <name>stateFlags</name></member> + <member><type>float</type> <name>batteryLevel</name></member> + </type> + + <!-- XR_META_environment_raycast --> + <type category="struct" name="XrSystemEnvironmentRaycastPropertiesMETA" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_ENVIRONMENT_RAYCAST_PROPERTIES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsEnvironmentRaycast</name></member> + </type> + + <type category="struct" name="XrEnvironmentRaycasterCreateInfoMETA"> + <member values="XR_TYPE_ENVIRONMENT_RAYCASTER_CREATE_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrEnvironmentRaycasterCreateCompletionMETA" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_ENVIRONMENT_RAYCASTER_CREATE_COMPLETION_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>XrEnvironmentRaycasterMETA</type> <name>environmentRaycaster</name></member> + </type> + + <type category="struct" name="XrEnvironmentRaycastFilterBaseHeaderMETA"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrEnvironmentRaycastFilterDistanceMETA" parentstruct="XrEnvironmentRaycastFilterBaseHeaderMETA"> + <member values="XR_TYPE_ENVIRONMENT_RAYCAST_FILTER_DISTANCE_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>maxDistance</name></member> + </type> + + <type category="struct" name="XrEnvironmentRaycastHitGetInfoMETA"> + <member values="XR_TYPE_ENVIRONMENT_RAYCAST_HIT_GET_INFO_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrVector3f</type> <name>origin</name></member> + <member><type>XrVector3f</type> <name>direction</name></member> + <member optional="true"><type>uint32_t</type> <name>filterCount</name></member> + <member optional="true" len="filterCount">const <type>XrEnvironmentRaycastFilterBaseHeaderMETA</type>* const * <name>filters</name></member> + </type> + + <type category="struct" name="XrEnvironmentRaycastHitMETA"> + <member values="XR_TYPE_ENVIRONMENT_RAYCAST_HIT_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrEnvironmentRaycastHitStatusMETA</type> <name>status</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + + <!-- XR_META_hand_tracking_unextrapolated_poses --> + <type category="struct" name="XrHandTrackingUnextrapolatedPosesRequestMETA" structextends="XrHandJointsLocateInfoEXT"> + <member values="XR_TYPE_HAND_TRACKING_UNEXTRAPOLATED_POSES_REQUEST_META"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrHandTrackingUnextrapolatedPosesMETA" structextends="XrHandJointLocationsEXT" returnedonly="true"> + <member values="XR_TYPE_HAND_TRACKING_UNEXTRAPOLATED_POSES_META"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>captureTime</name></member> + </type> + + <!-- XR_QCOM_hand_tracking_gesture --> + <type category="struct" name="XrHandGestureQCOM"> + <member><type>XrHandGestureTypeQCOM</type> <name>gesture</name></member> + <member><type>float</type> <name>gestureRatio</name></member> + <member><type>float</type> <name>flipRatio</name></member> + </type> + + <!-- XR_META_hand_tracking_frequency_hint --> + <type category="enum" name="XrHandTrackingFrequencyHintMETA"/> + + <!-- XR_EXT_haptic_parametric --> + <type category="struct" name="XrHapticParametricPropertiesEXT"> + <member values="XR_TYPE_HAPTIC_PARAMETRIC_PROPERTIES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrDuration</type> <name>idealFrameSubmissionRate</name></member> + <member><type>XrDuration</type> <name>minimumFirstFrameDuration</name></member> + <member><type>float</type> <name>minFrequencyHz</name></member> + <member><type>float</type> <name>maxFrequencyHz</name></member> + </type> + + <type category="struct" name="XrHapticParametricPointEXT"> + <member><type>XrDuration</type> <name>time</name></member> + <member><type>float</type> <name>value</name></member> + </type> + + <type category="struct" name="XrHapticParametricTransientEXT"> + <member><type>XrDuration</type> <name>time</name></member> + <member><type>float</type> <name>amplitude</name></member> + <member><type>float</type> <name>frequency</name></member> + </type> + + <type category="struct" name="XrHapticParametricVibrationEXT" parentstruct="XrHapticBaseHeader"> + <member values="XR_TYPE_HAPTIC_PARAMETRIC_VIBRATION_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + + <member><type>uint32_t</type> <name>amplitudePointCount</name></member> + <member len="amplitudePointCount">const <type>XrHapticParametricPointEXT</type>* <name>amplitudePoints</name></member> + + <member optional="true"><type>uint32_t</type> <name>frequencyPointCount</name></member> + <member optional="true" len="frequencyPointCount">const <type>XrHapticParametricPointEXT</type>* <name>frequencyPoints</name></member> + + <member optional="true"><type>uint32_t</type> <name>transientCount</name></member> + <member optional="true" len="transientCount">const <type>XrHapticParametricTransientEXT</type>* <name>transients</name></member> + + <member><type>float</type> <name>minFrequencyHz</name></member> + <member><type>float</type> <name>maxFrequencyHz</name></member> + + <member><type>XrHapticParametricStreamFrameTypeEXT</type> <name>streamFrameType</name></member> + </type> + + <type category="struct" name="XrSystemHapticParametricPropertiesEXT" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_HAPTIC_PARAMETRIC_PROPERTIES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsParametricHaptics</name></member> + </type> + + <!-- XR_ANDROID_google_cloud_auth --> + <type name="XrGoogleCloudAuthErrorANDROID" category="enum"/> + <type category="struct" name="XrGoogleCloudAuthInfoBaseHeaderANDROID"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrGoogleCloudAuthInfoApiKeyANDROID" parentstruct="XrGoogleCloudAuthInfoBaseHeaderANDROID"> + <member values="XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_API_KEY_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member len="null-terminated">const <type>char</type>* <name>apiKey</name></member> + </type> + <type category="struct" name="XrGoogleCloudAuthInfoTokenANDROID" parentstruct="XrGoogleCloudAuthInfoBaseHeaderANDROID"> + <member values="XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_TOKEN_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member len="null-terminated">const <type>char</type>* <name>authToken</name></member> + </type> + <type category="struct" name="XrGoogleCloudAuthInfoKeylessANDROID" parentstruct="XrGoogleCloudAuthInfoBaseHeaderANDROID"> + <member values="XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_KEYLESS_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrGoogleCloudAuthErrorResultANDROID" structextends="XrGoogleCloudAuthInfoBaseHeaderANDROID"> + <member values="XR_TYPE_GOOGLE_CLOUD_AUTH_ERROR_RESULT_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrGoogleCloudAuthErrorANDROID</type> <name>error</name></member> + </type> + + <!-- XR_SONY_swapchain_color_space --> + <type category="struct" name="XrColorSpacesEnumerateInfoSONY"> + <member values="XR_TYPE_COLOR_SPACES_ENUMERATE_INFO_SONY"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>int64_t</type> <name>format</name></member> + </type> + + <type category="struct" name="XrSwapchainCreateInfoColorSpaceSONY" structextends="XrSwapchainCreateInfo"> + <member values="XR_TYPE_SWAPCHAIN_CREATE_INFO_COLOR_SPACE_SONY"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrColorSpaceSONY</type> <name>colorSpace</name></member> + </type> + + <!-- XR_BD_camera_image --> + <type category="struct" name="XrAvailableCamerasEnumerateInfoBD"> + <member values="XR_TYPE_AVAILABLE_CAMERAS_ENUMERATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member optional="true">const <type>XrCameraPropertiesBD</type>* <name>properties</name></member> + <member optional="true">const <type>XrCameraCapabilitiesBD</type>* <name>capabilities</name></member> + </type> + <type category="struct" name="XrAvailableCameraBD" returnedonly="true"> + <member values="XR_TYPE_AVAILABLE_CAMERA_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrCameraIdBD</type> <name>cameraId</name></member> + </type> + <type category="struct" name="XrCameraPropertiesGetInfoBD"> + <member values="XR_TYPE_CAMERA_PROPERTIES_GET_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraIdBD</type> <name>cameraId</name></member> + </type> + <type category="struct" name="XrCameraPropertyBaseHeaderBD"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrCameraPropertiesBD"> + <member values="XR_TYPE_CAMERA_PROPERTIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>propertyCount</name></member> + <member len="propertyCount"><type>XrCameraPropertyBaseHeaderBD</type>** <name>properties</name></member> + </type> + <type category="struct" name="XrCameraPropertyFacingBD" parentstruct="XrCameraPropertyBaseHeaderBD"> + <member values="XR_TYPE_CAMERA_PROPERTY_FACING_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraFacingBD</type> <name>facing</name></member> + </type> + <type category="struct" name="XrCameraPropertyPositionBD" parentstruct="XrCameraPropertyBaseHeaderBD"> + <member values="XR_TYPE_CAMERA_PROPERTY_POSITION_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraPositionBD</type> <name>position</name></member> + </type> + <type category="struct" name="XrCameraPropertyCameraTypeBD" parentstruct="XrCameraPropertyBaseHeaderBD"> + <member values="XR_TYPE_CAMERA_PROPERTY_CAMERA_TYPE_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraTypeBD</type> <name>cameraType</name></member> + </type> + <type category="struct" name="XrCameraSupportedCapabilitiesGetInfoBD"> + <member values="XR_TYPE_CAMERA_SUPPORTED_CAPABILITIES_GET_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraIdBD</type> <name>id</name></member> + </type> + <type category="struct" name="XrCameraSupportedCapabilityBaseHeaderBD" returnedonly="true"> + <member><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrCameraSupportedCapabilitiesBD"> + <member values="XR_TYPE_CAMERA_SUPPORTED_CAPABILITIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>capabilityCount</name></member> + <member len="capabilityCount"><type>XrCameraSupportedCapabilityBaseHeaderBD</type>** <name>capabilities</name></member> + </type> + <type category="struct" name="XrCameraCapabilityBaseHeaderBD"> + <member><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrCameraCapabilitiesBD"> + <member values="XR_TYPE_CAMERA_CAPABILITIES_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>capabilityCount</name></member> + <member len="capabilityCount"><type>XrCameraCapabilityBaseHeaderBD</type>** <name>capabilities</name></member> + </type> + <type category="struct" name="XrCameraCapabilityTypesEnumerateInfoBD"> + <member values="XR_TYPE_CAMERA_CAPABILITY_TYPES_ENUMERATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraIdBD</type> <name>cameraId</name></member> + </type> + <type category="struct" name="XrCameraCapabilityTypesBD"> + <member values="XR_TYPE_CAMERA_CAPABILITY_TYPES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>capabilityTypeCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>capabilityTypeCountOutput</name></member> + <member optional="true" len="capabilityTypeCapacityInput"><type>XrCameraCapabilityTypeBD</type>* <name>capabilityTypes</name></member> + </type> + <type category="struct" name="XrCameraPropertyTypesEnumerateInfoBD"> + <member values="XR_TYPE_CAMERA_PROPERTY_TYPES_ENUMERATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraIdBD</type> <name>cameraId</name></member> + </type> + <type category="struct" name="XrCameraPropertyTypesBD"> + <member values="XR_TYPE_CAMERA_PROPERTY_TYPES_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>propertyTypeCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>propertyTypeCountOutput</name></member> + <member optional="true" len="propertyTypeCapacityInput"><type>XrCameraPropertyTypeBD</type>* <name>propertyTypes</name></member> + </type> + <type category="struct" name="XrCameraImageResolutionAndFrameRateBD"> + <member><type>XrExtent2Di</type> <name>resolution</name></member> + <member><type>uint32_t</type> <name>frameRate</name></member> + </type> + <type category="struct" name="XrCameraSupportedCapabilityImageResolutionAndFrameRateBD" parentstruct="XrCameraSupportedCapabilityBaseHeaderBD" returnedonly="true"> + <member values="XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_IMAGE_RESOLUTION_AND_FRAME_RATE_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>resolutionAndFrameRateCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>resolutionAndFrameRateCountOutput</name></member> + <member optional="true" len="resolutionAndFrameRateCapacityInput"><type>XrCameraImageResolutionAndFrameRateBD</type>* <name>resolutionAndFrameRates</name></member> + </type> + <type category="struct" name="XrCameraCapabilityImageResolutionAndFrameRateBD" parentstruct="XrCameraCapabilityBaseHeaderBD"> + <member values="XR_TYPE_CAMERA_CAPABILITY_IMAGE_RESOLUTION_AND_FRAME_RATE_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrExtent2Di</type> <name>resolution</name></member> + <member><type>uint32_t</type> <name>frameRate</name></member> + </type> + <type category="struct" name="XrCameraSupportedCapabilityDataTransferTypeBD" parentstruct="XrCameraSupportedCapabilityBaseHeaderBD" returnedonly="true"> + <member values="XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_DATA_TRANSFER_TYPE_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>transferTypeCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>transferTypeCountOutput</name></member> + <member optional="true" len="transferTypeCapacityInput"><type>XrCameraDataTransferTypeBD</type>* <name>transferTypes</name></member> + </type> + <type category="struct" name="XrCameraCapabilityDataTransferTypeBD" parentstruct="XrCameraCapabilityBaseHeaderBD"> + <member values="XR_TYPE_CAMERA_CAPABILITY_DATA_TRANSFER_TYPE_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraDataTransferTypeBD</type> <name>transferType</name></member> + </type> + <type category="struct" name="XrCameraSupportedCapabilityImageFormatBD" parentstruct="XrCameraSupportedCapabilityBaseHeaderBD" returnedonly="true"> + <member values="XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_IMAGE_FORMAT_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>formatCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>formatCountOutput</name></member> + <member optional="true" len="formatCapacityInput"><type>XrCameraImageFormatBD</type>* <name>formats</name></member> + </type> + <type category="struct" name="XrCameraCapabilityImageFormatBD" parentstruct="XrCameraCapabilityBaseHeaderBD"> + <member values="XR_TYPE_CAMERA_CAPABILITY_IMAGE_FORMAT_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraImageFormatBD</type> <name>format</name></member> + </type> + <type category="struct" name="XrCameraSupportedCapabilityCameraModelBD" parentstruct="XrCameraSupportedCapabilityBaseHeaderBD" returnedonly="true"> + <member values="XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_CAMERA_MODEL_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member optional="true"><type>uint32_t</type> <name>modelCapacityInput</name></member> + <member optional="true"><type>uint32_t</type> <name>modelCountOutput</name></member> + <member optional="true" len="modelCapacityInput"><type>XrCameraModelBD</type>* <name>models</name></member> + </type> + <type category="struct" name="XrCameraCapabilityCameraModelBD" parentstruct="XrCameraCapabilityBaseHeaderBD"> + <member values="XR_TYPE_CAMERA_CAPABILITY_CAMERA_MODEL_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraModelBD</type> <name>model</name></member> + </type> + <type category="struct" name="XrCameraDeviceCreateInfoBD"> + <member values="XR_TYPE_CAMERA_DEVICE_CREATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraIdBD</type> <name>cameraId</name></member> + </type> + <type category="struct" name="XrCreateCameraDeviceCompletionBD" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_CREATE_CAMERA_DEVICE_COMPLETION_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>XrCameraDeviceBD</type> <name>device</name></member> + </type> + <type category="struct" name="XrCameraCaptureSessionCreateInfoBD"> + <member values="XR_TYPE_CAMERA_CAPTURE_SESSION_CREATE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrCameraDeviceBD</type> <name>camera</name></member> + <member><type>uint32_t</type> <name>configCount</name></member> + <member len="configCount">const <type>XrCameraCapabilityBaseHeaderBD</type>* const* <name>configs</name></member> + </type> + <type category="struct" name="XrCreateCameraCaptureSessionCompletionBD" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_CREATE_CAMERA_CAPTURE_SESSION_COMPLETION_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>XrCameraCaptureSessionBD</type> <name>captureSession</name></member> + </type> + <type category="struct" name="XrCameraIntrinsicsBD" structextends="XrCameraImageDataBaseHeaderBD"> + <member values="XR_TYPE_CAMERA_INTRINSICS_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrVector2f</type> <name>focalLength</name></member> + <member><type>XrVector2f</type> <name>principalPoint</name></member> + <member><type>XrVector2f</type> <name>fov</name></member> + </type> + <type category="struct" name="XrCameraExtrinsicsBD" structextends="XrCameraImageDataBaseHeaderBD"> + <member values="XR_TYPE_CAMERA_EXTRINSICS_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + </type> + <type category="struct" name="XrCameraCaptureBeginInfoBD"> + <member values="XR_TYPE_CAMERA_CAPTURE_BEGIN_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrCameraImageAcquireInfoBD"> + <member values="XR_TYPE_CAMERA_IMAGE_ACQUIRE_INFO_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>lastCaptureTime</name></member> + </type> + <type category="struct" name="XrCameraImageBD"> + <member values="XR_TYPE_CAMERA_IMAGE_BD"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>available</name></member> + <member><type>XrTime</type> <name>captureTime</name></member> + <member><type>XrCameraImageIdBD</type> <name>imageId</name></member> + </type> + <type category="struct" name="XrCameraImageDataBaseHeaderBD"> + <member><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + </type> + <type category="struct" name="XrCameraImageDataRawBufferBD" parentstruct="XrCameraImageDataBaseHeaderBD"> + <member values="XR_TYPE_CAMERA_IMAGE_DATA_RAW_BUFFER_BD"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>width</name></member> + <member><type>uint32_t</type> <name>height</name></member> + <member><type>uint32_t</type> <name>stride</name></member> + <member><type>uint32_t</type> <name>bytesPerPixel</name></member> + <member><type>uint32_t</type> <name>pixelStride</name></member> + <member><type>uint32_t</type> <name>bufferSize</name></member> + <member len="bufferSize"><type>uint8_t</type>* <name>buffer</name></member> + </type> + + <!-- XR_SONY_hdr_metadata --> + <type category="struct" name="XrHdrMetadataSONY"> + <member values="XR_TYPE_HDR_METADATA_SONY"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrXYColorSONY</type> <name>displayPrimaryRed</name></member> + <member><type>XrXYColorSONY</type> <name>displayPrimaryGreen</name></member> + <member><type>XrXYColorSONY</type> <name>displayPrimaryBlue</name></member> + <member><type>XrXYColorSONY</type> <name>whitePoint</name></member> + <member><type>float</type> <name>maxLuminance</name></member> + <member><type>float</type> <name>minLuminance</name></member> + <member><type>float</type> <name>maxContentLightLevel</name></member> + <member><type>float</type> <name>maxFrameAverageLightLevel</name></member> + </type> + + <type category="struct" name="XrXYColorSONY"> + <member><type>float</type> <name>x</name></member> + <member><type>float</type> <name>y</name></member> + </type> + + <!-- XR_ANDROID_trackables --> + <type category="define"> +#define <name>XR_NULL_TRACKABLE_ANDROID</name> 0</type> + + <type category="basetype"><type>XR_DEFINE_ATOM</type>(<name>XrTrackableANDROID</name>)</type> + + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrTrackableTrackerANDROID</name>)</type> + + <type name="XrTrackingStateANDROID" category="enum"/> + <type name="XrTrackableTypeANDROID" category="enum"/> + <type name="XrPlaneTypeANDROID" category="enum"/> + <type name="XrPlaneLabelANDROID" category="enum"/> + + <type category="struct" name="XrTrackableTrackerCreateInfoANDROID"> + <member values="XR_TYPE_TRACKABLE_TRACKER_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTrackableTypeANDROID</type> <name>trackableType</name></member> + </type> + <type category="struct" name="XrTrackableGetInfoANDROID"> + <member values="XR_TYPE_TRACKABLE_GET_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTrackableANDROID</type> <name>trackable</name></member> + <member><type>XrSpace</type> <name>baseSpace</name></member> + <member><type>XrTime</type> <name>time</name></member> + </type> + <type category="struct" name="XrTrackablePlaneANDROID"> + <member values="XR_TYPE_TRACKABLE_PLANE_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrTrackingStateANDROID</type> <name>trackingState</name></member> + <member><type>XrPosef</type> <name>centerPose</name></member> + <member><type>XrExtent2Df</type> <name>extents</name></member> + <member><type>XrPlaneTypeANDROID</type> <name>planeType</name></member> + <member><type>XrPlaneLabelANDROID</type> <name>planeLabel</name></member> + <member><type>XrTrackableANDROID</type> <name>subsumedByPlane</name></member> + <member><type>XrTime</type> <name>lastUpdatedTime</name></member> + <member optional="true"><type>uint32_t</type> <name>vertexCapacityInput</name></member> + <member optional="true"><type>uint32_t</type>* <name>vertexCountOutput</name></member> + <member optional="true" len="vertexCapacityInput"><type>XrVector2f</type>* <name>vertices</name></member> + </type> + <type category="struct" name="XrAnchorSpaceCreateInfoANDROID"> + <member values="XR_TYPE_ANCHOR_SPACE_CREATE_INFO_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrTime</type> <name>time</name></member> + <member><type>XrPosef</type> <name>pose</name></member> + <member><type>XrTrackableANDROID</type> <name>trackable</name></member> + </type> + <type category="struct" name="XrSystemTrackablesPropertiesANDROID" returnedonly="true" structextends="XrSystemProperties"> + <member values="XR_TYPE_SYSTEM_TRACKABLES_PROPERTIES_ANDROID"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>supportsAnchor</name></member> + <member><type>uint32_t</type> <name>maxAnchors</name></member> + </type> + + <!-- XR_EXT_spatial_container --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSpatialContainerEXT</name>)</type> + + <type category="enum" name="XrSpatialContainerGraphicsPresentationEXT"/> + <type category="enum" name="XrSpatialContainerBoundsModeEXT"/> + <type category="enum" name="XrSpatialContainerVolumeClippingEXT"/> + + <type category="struct" name="XrSpatialContainerCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_CONTAINER_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialContainerGraphicsPresentationEXT</type> <name>graphicsPresentation</name></member> + <member><type>XrExtent3Df</type> <name>suggestedBounds</name></member> + </type> + + <type category="struct" name="XrSpatialContainerSpaceCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_CONTAINER_SPACE_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialContainerEXT</type> <name>spatialContainer</name></member> + </type> + + <type category="struct" name="XrEventDataSpatialContainerClosedEXT" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_CLOSED_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialContainerEXT</type> <name>spatialContainer</name></member> + </type> + + <type category="struct" name="XrSystemSpatialContainerPropertiesEXT" structextends="XrSystemProperties" returnedonly="true"> + <member values="XR_TYPE_SYSTEM_SPATIAL_CONTAINER_PROPERTIES_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>maxSpatialContainerCount</name></member> + <member><type>XrBool32</type> <name>supportsBounded</name></member> + <member><type>XrBool32</type> <name>supportsImmersive</name></member> + </type> + + <type category="struct" name="XrSpatialContainerBoundsEXT" returnedonly="true"> + <member values="XR_TYPE_SPATIAL_CONTAINER_BOUNDS_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrExtent3Df</type> <name>bounds</name></member> + <member><type>XrBool32</type> <name>infiniteBounds</name></member> + </type> + + <type category="struct" name="XrEventDataSpatialContainerBoundsChangedEXT" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_BOUNDS_CHANGED_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialContainerEXT</type> <name>spatialContainer</name></member> + <member><type>XrExtent3Df</type> <name>bounds</name></member> + <member><type>XrBool32</type> <name>infiniteBounds</name></member> + <member><type>XrSpatialContainerBoundsModeEXT</type> <name>boundsMode</name></member> + </type> + + <type category="struct" name="XrSpatialContainerBoundsGetInfoEXT"> + <member values="XR_TYPE_SPATIAL_CONTAINER_BOUNDS_GET_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrSpatialContainerStateGetInfoEXT"> + <member values="XR_TYPE_SPATIAL_CONTAINER_STATE_GET_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <type category="struct" name="XrSpatialContainerVisibleRequestInfoEXT"> + <member values="XR_TYPE_SPATIAL_CONTAINER_VISIBLE_REQUEST_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>visible</name></member> + </type> + + <type category="struct" name="XrEventDataSpatialContainerVisibleChangedEXT" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_VISIBLE_CHANGED_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialContainerEXT</type> <name>spatialContainer</name></member> + <member><type>XrBool32</type> <name>visible</name></member> + </type> + + <type category="struct" name="XrEventDataSpatialContainerVisibleRequestDeniedEXT" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_VISIBLE_REQUEST_DENIED_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialContainerEXT</type> <name>spatialContainer</name></member> + </type> + + <type category="struct" name="XrEventDataSpatialContainerInteractableChangedEXT" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_INTERACTABLE_CHANGED_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialContainerEXT</type> <name>spatialContainer</name></member> + <member><type>XrBool32</type> <name>interactable</name></member> + </type> + + <type category="struct" name="XrSpatialContainerBoundsModeRequestInfoEXT"> + <member values="XR_TYPE_SPATIAL_CONTAINER_BOUNDS_MODE_REQUEST_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialContainerBoundsModeEXT</type> <name>boundsMode</name></member> + </type> + + <type category="struct" name="XrEventDataSpatialContainerBoundsModeRequestDeniedEXT" parentstruct="XrEventDataBaseHeader" returnedonly="true"> + <member values="XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_BOUNDS_MODE_REQUEST_DENIED_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialContainerEXT</type> <name>spatialContainer</name></member> + </type> + + <type category="struct" name="XrSpatialContainerStateEXT" returnedonly="true"> + <member values="XR_TYPE_SPATIAL_CONTAINER_STATE_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>visible</name></member> + <member><type>XrBool32</type> <name>interactable</name></member> + <member><type>XrSpatialContainerBoundsModeEXT</type> <name>boundsMode</name></member> + </type> + + <type category="struct" name="XrSessionCreateInfoSpatialContainersEXT" structextends="XrSessionCreateInfo"> + <member values="XR_TYPE_SESSION_CREATE_INFO_SPATIAL_CONTAINERS_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + </type> + + <!-- XR_EXT_spatial_container_self_rendering --> + <type category="struct" name="XrSpatialContainerBeginInfoEXT"> + <member values="XR_TYPE_SPATIAL_CONTAINER_BEGIN_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialContainerEXT</type> <name>spatialContainer</name></member> + <member><type>XrViewConfigurationType</type> <name>primaryViewConfigurationType</name></member> + </type> + + <type category="struct" name="XrSpatialContainerEndInfoEXT"> + <member values="XR_TYPE_SPATIAL_CONTAINER_END_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialContainerEXT</type> <name>spatialContainer</name></member> + </type> + + <type category="struct" name="XrSpatialContainerViewLocateInfoEXT"> + <member values="XR_TYPE_SPATIAL_CONTAINER_VIEW_LOCATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></member> + <member><type>XrSpace</type> <name>space</name></member> + <member><type>XrSpatialContainerEXT</type> <name>spatialContainer</name></member> + </type> + + <type category="struct" name="XrSpatialContainerViewsLocateInfoEXT"> + <member values="XR_TYPE_SPATIAL_CONTAINER_VIEWS_LOCATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrTime</type> <name>displayTime</name></member> + <member><type>uint32_t</type> <name>viewLocateInfoCount</name></member> + <member len="viewLocateInfoCount">const <type>XrSpatialContainerViewLocateInfoEXT</type>* <name>viewLocateInfos</name></member> + </type> + + <type category="struct" name="XrSpatialContainerViewStateEXT"> + <member values="XR_TYPE_SPATIAL_CONTAINER_VIEW_STATE_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrViewStateFlags</type> <name>viewStateFlags</name></member> + <member><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></member> + <member><type>XrBool32</type> <name>shouldSubmitLayers</name></member> + <member><type>XrExtent2Di</type> <name>recommendedImageExtent</name></member> + </type> + + <type category="struct" name="XrSpatialContainerLayerEXT"> + <member values="XR_TYPE_SPATIAL_CONTAINER_LAYER_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialContainerEXT</type> <name>spatialContainer</name></member> + <member><type>XrBool32</type> <name>retainPreviousSubmission</name></member> + <member optional="true"><type>uint32_t</type> <name>layerCount</name></member> + <member optional="true" len="layerCount">const <type>XrCompositionLayerBaseHeader</type>* const* <name>layers</name></member> + </type> + + <type category="struct" name="XrSpatialContainerLayerFrameEndInfoEXT" structextends="XrFrameEndInfo"> + <member values="XR_TYPE_SPATIAL_CONTAINER_LAYER_FRAME_END_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>containerLayerCount</name></member> + <member len="containerLayerCount">const <type>XrSpatialContainerLayerEXT</type>* <name>containerLayers</name></member> + </type> + + <type category="struct" name="XrSpatialContainerCompositionLayerViewConfigurationEXT" structextends="XrCompositionLayerProjection"> + <member values="XR_TYPE_SPATIAL_CONTAINER_COMPOSITION_LAYER_VIEW_CONFIGURATION_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></member> + </type> + + <type category="struct" name="XrSpatialContainerLayerVolumeClippingEXT" structextends="XrSpatialContainerLayerEXT"> + <member values="XR_TYPE_SPATIAL_CONTAINER_LAYER_VOLUME_CLIPPING_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialContainerVolumeClippingEXT</type> <name>volumeClipping</name></member> + </type> + + <!-- XR_EXT_spatial_image_tracking --> + <type category="handle" parent="XrSession"><type>XR_DEFINE_HANDLE</type>(<name>XrSpatialImageTrackingDatabaseEXT</name>)</type> + + <type name="XrSpatialReferenceImageFormatEXT" category="enum"/> + + <type category="struct" name="XrSpatialReferenceImagePlaneEXT"> + <member><type>uint32_t</type> <name>bufferSize</name></member> + <member len="bufferSize">const <type>uint8_t</type>* <name>buffer</name></member> + <member><type>uint32_t</type> <name>rowStride</name></member> + <member><type>uint32_t</type> <name>pixelStride</name></member> + </type> + + <type category="struct" name="XrSpatialReferenceImageEXT"> + <member values="XR_TYPE_SPATIAL_REFERENCE_IMAGE_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>width</name></member> + <member><type>uint32_t</type> <name>height</name></member> + <member><type>XrSpatialReferenceImageFormatEXT</type> <name>format</name></member> + <member><type>uint32_t</type> <name>planeCount</name></member> + <member len="planeCount">const <type>XrSpatialReferenceImagePlaneEXT</type>* <name>planes</name></member> + </type> + + <type category="struct" name="XrSpatialImageStaticOptimizationEXT" structextends="XrSpatialReferenceImageEXT,XrSpatialImageTrackingDatabaseCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_IMAGE_STATIC_OPTIMIZATION_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrBool32</type> <name>optimizeForStaticImage</name></member> + </type> + + <type category="struct" name="XrSpatialImageSizeEXT" structextends="XrSpatialReferenceImageEXT,XrSpatialImageTrackingDatabaseCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_IMAGE_SIZE_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>float</type> <name>physicalWidth</name></member> + </type> + + <type category="struct" name="XrSpatialCapabilityConfigurationImageTrackingEXT" parentstruct="XrSpatialCapabilityConfigurationBaseHeaderEXT"> + <member values="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_IMAGE_TRACKING_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>XrSpatialCapabilityEXT</type> <name>capability</name></member> + <member><type>uint32_t</type> <name>enabledComponentCount</name></member> + <member len="enabledComponentCount">const <type>XrSpatialComponentTypeEXT</type>* <name>enabledComponents</name></member> + <member><type>uint32_t</type> <name>imageTrackingDatabaseCount</name></member> + <member len="imageTrackingDatabaseCount">const <type>XrSpatialImageTrackingDatabaseEXT</type>* <name>imageTrackingDatabases</name></member> + </type> + + <type category="struct" name="XrSpatialImageTrackingDatabaseCreateInfoEXT"> + <member values="XR_TYPE_SPATIAL_IMAGE_TRACKING_DATABASE_CREATE_INFO_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>spatialReferenceImageCount</name></member> + <member len="spatialReferenceImageCount">const <type>XrSpatialReferenceImageEXT</type>* <name>spatialReferenceImages</name></member> + </type> + + <type category="struct" name="XrSpatialImage2DDataEXT"> + <member><type>XrSpatialImageTrackingDatabaseEXT</type> <name>imageTrackingDatabase</name></member> + <member><type>uint32_t</type> <name>referenceImageIndex</name></member> + </type> + + <type category="struct" name="XrSpatialComponentImage2DListEXT" structextends="XrSpatialComponentDataQueryResultEXT"> + <member values="XR_TYPE_SPATIAL_COMPONENT_IMAGE_2D_LIST_EXT"><type>XrStructureType</type> <name>type</name></member> + <member>const <type>void</type>* <name>next</name></member> + <member><type>uint32_t</type> <name>imageCount</name></member> + <member len="imageCount"><type>XrSpatialImage2DDataEXT</type>* <name>images</name></member> + </type> + + <type category="struct" name="XrCreateSpatialImageTrackingDatabaseCompletionEXT" parentstruct="XrFutureCompletionBaseHeaderEXT"> + <member values="XR_TYPE_CREATE_SPATIAL_IMAGE_TRACKING_DATABASE_COMPLETION_EXT"><type>XrStructureType</type> <name>type</name></member> + <member><type>void</type>* <name>next</name></member> + <member><type>XrResult</type> <name>futureResult</name></member> + <member><type>XrSpatialImageTrackingDatabaseEXT</type> <name>database</name></member> + </type> + + </types> + + + <!-- SECTION: OpenXR enumerant (token) definitions. --> + + <enums name="API Constants" comment="Misc. hardcoded constants - not an enumerated type"> + <!-- This is part of the header boilerplate --> + <enum value="1" name="XR_TRUE"/> + <enum value="0" name="XR_FALSE"/> + <enum value="128" name="XR_MAX_EXTENSION_NAME_SIZE"/> + <enum value="256" name="XR_MAX_API_LAYER_NAME_SIZE"/> + <enum value="256" name="XR_MAX_API_LAYER_DESCRIPTION_SIZE"/> + <enum value="256" name="XR_MAX_SYSTEM_NAME_SIZE"/> + <enum value="128" name="XR_MAX_APPLICATION_NAME_SIZE"/> + <enum value="128" name="XR_MAX_ENGINE_NAME_SIZE"/> + <enum value="128" name="XR_MAX_RUNTIME_NAME_SIZE"/> + <enum value="256" name="XR_MAX_PATH_LENGTH"/> + <enum value="64" name="XR_MAX_STRUCTURE_NAME_SIZE"/> + <enum value="64" name="XR_MAX_RESULT_STRING_SIZE"/> + <enum value="32" name="XR_MAX_GRAPHICS_APIS_SUPPORTED"/> + <enum value="64" name="XR_MAX_ACTION_SET_NAME_SIZE"/> + <enum value="64" name="XR_MAX_ACTION_NAME_SIZE"/> + <enum value="128" name="XR_MAX_LOCALIZED_ACTION_SET_NAME_SIZE"/> + <enum value="128" name="XR_MAX_LOCALIZED_ACTION_NAME_SIZE"/> + <enum value="16" name="XR_UUID_SIZE"/> + </enums> + + <!-- Unlike OpenGL, most tokens in OpenXR are actual typed enumerants in + their own numeric namespaces. The "name" attribute is the C enum + type name, and is pulled in from a <type> definition above + (slightly clunky, but retains the type / enum distinction). "type" + attributes of "enum" or "bitmask" indicate that these values should + be generated inside an appropriate definition. --> + + <enums name="XrStructureType" type="enum" comment="Structure type enumerant"> + <enum value="0" name="XR_TYPE_UNKNOWN"/> + <enum value="1" name="XR_TYPE_API_LAYER_PROPERTIES"/> + <enum value="2" name="XR_TYPE_EXTENSION_PROPERTIES"/> + <enum value="3" name="XR_TYPE_INSTANCE_CREATE_INFO"/> + <enum value="4" name="XR_TYPE_SYSTEM_GET_INFO"/> + <enum value="5" name="XR_TYPE_SYSTEM_PROPERTIES"/> + <enum value="6" name="XR_TYPE_VIEW_LOCATE_INFO"/> + <enum value="7" name="XR_TYPE_VIEW"/> + <enum value="8" name="XR_TYPE_SESSION_CREATE_INFO"/> + <enum value="9" name="XR_TYPE_SWAPCHAIN_CREATE_INFO"/> + <enum value="10" name="XR_TYPE_SESSION_BEGIN_INFO"/> + <enum value="11" name="XR_TYPE_VIEW_STATE"/> + <enum value="12" name="XR_TYPE_FRAME_END_INFO"/> + <enum value="13" name="XR_TYPE_HAPTIC_VIBRATION"/> + <enum value="16" name="XR_TYPE_EVENT_DATA_BUFFER"/> + <enum value="17" name="XR_TYPE_EVENT_DATA_INSTANCE_LOSS_PENDING"/> + <enum value="18" name="XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED"/> + <enum value="23" name="XR_TYPE_ACTION_STATE_BOOLEAN"/> + <enum value="24" name="XR_TYPE_ACTION_STATE_FLOAT"/> + <enum value="25" name="XR_TYPE_ACTION_STATE_VECTOR2F"/> + <enum value="27" name="XR_TYPE_ACTION_STATE_POSE"/> + <enum value="28" name="XR_TYPE_ACTION_SET_CREATE_INFO"/> + <enum value="29" name="XR_TYPE_ACTION_CREATE_INFO"/> + <enum value="32" name="XR_TYPE_INSTANCE_PROPERTIES"/> + <enum value="33" name="XR_TYPE_FRAME_WAIT_INFO"/> + <enum value="35" name="XR_TYPE_COMPOSITION_LAYER_PROJECTION"/> + <enum value="36" name="XR_TYPE_COMPOSITION_LAYER_QUAD"/> + <enum value="37" name="XR_TYPE_REFERENCE_SPACE_CREATE_INFO"/> + <enum value="38" name="XR_TYPE_ACTION_SPACE_CREATE_INFO"/> + <enum value="40" name="XR_TYPE_EVENT_DATA_REFERENCE_SPACE_CHANGE_PENDING"/> + <enum value="41" name="XR_TYPE_VIEW_CONFIGURATION_VIEW"/> + <enum value="42" name="XR_TYPE_SPACE_LOCATION"/> + <enum value="43" name="XR_TYPE_SPACE_VELOCITY"/> + <enum value="44" name="XR_TYPE_FRAME_STATE"/> + <enum value="45" name="XR_TYPE_VIEW_CONFIGURATION_PROPERTIES"/> + <enum value="46" name="XR_TYPE_FRAME_BEGIN_INFO"/> + <enum value="48" name="XR_TYPE_COMPOSITION_LAYER_PROJECTION_VIEW"/> + <enum value="49" name="XR_TYPE_EVENT_DATA_EVENTS_LOST"/> + <enum value="51" name="XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING"/> + <enum value="52" name="XR_TYPE_EVENT_DATA_INTERACTION_PROFILE_CHANGED"/> + <enum value="53" name="XR_TYPE_INTERACTION_PROFILE_STATE"/> + <enum value="55" name="XR_TYPE_SWAPCHAIN_IMAGE_ACQUIRE_INFO"/> + <enum value="56" name="XR_TYPE_SWAPCHAIN_IMAGE_WAIT_INFO"/> + <enum value="57" name="XR_TYPE_SWAPCHAIN_IMAGE_RELEASE_INFO"/> + <enum value="58" name="XR_TYPE_ACTION_STATE_GET_INFO"/> + <enum value="59" name="XR_TYPE_HAPTIC_ACTION_INFO"/> + <enum value="60" name="XR_TYPE_SESSION_ACTION_SETS_ATTACH_INFO"/> + <enum value="61" name="XR_TYPE_ACTIONS_SYNC_INFO"/> + <enum value="62" name="XR_TYPE_BOUND_SOURCES_FOR_ACTION_ENUMERATE_INFO"/> + <enum value="63" name="XR_TYPE_INPUT_SOURCE_LOCALIZED_NAME_GET_INFO"/> + </enums> + <enums name="XrResult" type="enum" comment="Error and return codes"> + <!-- Return codes for successful operation execution (positive values) --> + <enum value="0" name="XR_SUCCESS" comment="Function successfully completed."/> + <enum value="1" name="XR_TIMEOUT_EXPIRED" comment="The specified timeout time occurred before the operation could complete."/> + <enum value="3" name="XR_SESSION_LOSS_PENDING" comment="The session will be lost soon."/> + <enum value="4" name="XR_EVENT_UNAVAILABLE" comment="No event was available."/> + <enum value="7" name="XR_SPACE_BOUNDS_UNAVAILABLE" comment="The space's bounds are not known at the moment."/> + <enum value="8" name="XR_SESSION_NOT_FOCUSED" comment="The session is not in the focused state, and if spatial containers are enabled no spatial container exists that is interactable."/> + <enum value="9" name="XR_FRAME_DISCARDED" comment="A frame has been discarded from composition."/> + <!-- Error codes (negative values) --> + <enum value="-1" name="XR_ERROR_VALIDATION_FAILURE" comment="The function usage was invalid in some way."/> + <enum value="-2" name="XR_ERROR_RUNTIME_FAILURE" comment="The runtime failed to handle the function in an unexpected way that is not covered by another error result. "/> + <enum value="-3" name="XR_ERROR_OUT_OF_MEMORY" comment="A memory allocation has failed."/> + <enum value="-4" name="XR_ERROR_API_VERSION_UNSUPPORTED" comment="The runtime does not support the requested API version."/> + <enum value="-6" name="XR_ERROR_INITIALIZATION_FAILED" comment="Initialization of object could not be completed."/> + <enum value="-7" name="XR_ERROR_FUNCTION_UNSUPPORTED" comment="The requested function was not found or is otherwise unsupported."/> + <enum value="-8" name="XR_ERROR_FEATURE_UNSUPPORTED" comment="The requested feature is not supported."/> + <enum value="-9" name="XR_ERROR_EXTENSION_NOT_PRESENT" comment="A requested extension is not supported."/> + <enum value="-10" name="XR_ERROR_LIMIT_REACHED" comment="The runtime supports no more of the requested resource."/> + <enum value="-11" name="XR_ERROR_SIZE_INSUFFICIENT" comment="The supplied size was smaller than required."/> + <enum value="-12" name="XR_ERROR_HANDLE_INVALID" comment="A supplied object handle was invalid."/> + <enum value="-13" name="XR_ERROR_INSTANCE_LOST" comment="The slink:XrInstance was lost or could not be found. It will need to be destroyed and optionally recreated."/> + <enum value="-14" name="XR_ERROR_SESSION_RUNNING" comment="The session <<session-running, is already running>>."/> + <enum value="-16" name="XR_ERROR_SESSION_NOT_RUNNING" comment="The session <<session-not-running, is not yet running>>."/> + <enum value="-17" name="XR_ERROR_SESSION_LOST" comment="The slink:XrSession was lost. It will need to be destroyed and optionally recreated."/> + <enum value="-18" name="XR_ERROR_SYSTEM_INVALID" comment="The provided basetype:XrSystemId was invalid."/> + <enum value="-19" name="XR_ERROR_PATH_INVALID" comment="The provided basetype:XrPath was not valid."/> + <enum value="-20" name="XR_ERROR_PATH_COUNT_EXCEEDED" comment="The maximum number of supported semantic paths has been reached."/> + <enum value="-21" name="XR_ERROR_PATH_FORMAT_INVALID" comment="The semantic path character format is invalid."/> + <enum value="-22" name="XR_ERROR_PATH_UNSUPPORTED" comment="The semantic path is unsupported."/> + <enum value="-23" name="XR_ERROR_LAYER_INVALID" comment="The layer was NULL or otherwise invalid."/> + <enum value="-24" name="XR_ERROR_LAYER_LIMIT_EXCEEDED" comment="The number of specified layers is greater than the supported number."/> + <enum value="-25" name="XR_ERROR_SWAPCHAIN_RECT_INVALID" comment="The image rect was negatively sized or otherwise invalid."/> + <enum value="-26" name="XR_ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED" comment="The image format is not supported by the runtime or platform."/> + <enum value="-27" name="XR_ERROR_ACTION_TYPE_MISMATCH" comment="The API used to retrieve an action's state does not match the action's type."/> + <enum value="-28" name="XR_ERROR_SESSION_NOT_READY" comment="The session is not in the ready state."/> + <enum value="-29" name="XR_ERROR_SESSION_NOT_STOPPING" comment="The session is not in the stopping state."/> + <enum value="-30" name="XR_ERROR_TIME_INVALID" comment="The provided basetype:XrTime was zero, negative, or out of range."/> + <enum value="-31" name="XR_ERROR_REFERENCE_SPACE_UNSUPPORTED" comment="The specified reference space is not supported by the runtime or system."/> + <enum value="-32" name="XR_ERROR_FILE_ACCESS_ERROR" comment="The file could not be accessed."/> + <enum value="-33" name="XR_ERROR_FILE_CONTENTS_INVALID" comment="The file's contents were invalid."/> + <enum value="-34" name="XR_ERROR_FORM_FACTOR_UNSUPPORTED" comment="The specified form factor is not supported by the current runtime or platform."/> + <enum value="-35" name="XR_ERROR_FORM_FACTOR_UNAVAILABLE" comment="The specified form factor is supported, but the device is currently not available, e.g. not plugged in or powered off."/> + <enum value="-36" name="XR_ERROR_API_LAYER_NOT_PRESENT" comment="A requested API layer is not present or could not be loaded."/> + <enum value="-37" name="XR_ERROR_CALL_ORDER_INVALID" comment="The call was made without having made a previously required call."/> + <enum value="-38" name="XR_ERROR_GRAPHICS_DEVICE_INVALID" comment="The given graphics device is not in a valid state. The graphics device could be lost or initialized without meeting graphics requirements."/> + <enum value="-39" name="XR_ERROR_POSE_INVALID" comment="The supplied pose was invalid with respect to the requirements."/> + <enum value="-40" name="XR_ERROR_INDEX_OUT_OF_RANGE" comment="The supplied index was outside the range of valid indices."/> + <enum value="-41" name="XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED" comment="The specified view configuration type is not supported by the runtime or platform."/> + <enum value="-42" name="XR_ERROR_ENVIRONMENT_BLEND_MODE_UNSUPPORTED" comment="The specified environment blend mode is not supported by the runtime or platform."/> + <enum value="-44" name="XR_ERROR_NAME_DUPLICATED" comment="The name provided was a duplicate of an already-existing resource."/> + <enum value="-45" name="XR_ERROR_NAME_INVALID" comment="The name provided was invalid."/> + <enum value="-46" name="XR_ERROR_ACTIONSET_NOT_ATTACHED" comment="A referenced action set is not attached to the session."/> + <enum value="-47" name="XR_ERROR_ACTIONSETS_ALREADY_ATTACHED" comment="The session already has attached action sets."/> + <enum value="-48" name="XR_ERROR_LOCALIZED_NAME_DUPLICATED" comment="The localized name provided was a duplicate of an already-existing resource."/> + <enum value="-49" name="XR_ERROR_LOCALIZED_NAME_INVALID" comment="The localized name provided was invalid."/> + <enum value="-50" name="XR_ERROR_GRAPHICS_REQUIREMENTS_CALL_MISSING" comment="The ftext:xrGet*GraphicsRequirements call was not made before calling fname:xrCreateSession."/> + <enum value="-51" name="XR_ERROR_RUNTIME_UNAVAILABLE" comment="The loader was unable to find or load a runtime."/> + <unused start="-100"/> + </enums> + <enums name="XrObjectType" type="enum" comment="Enums to track objects of various types"> + <enum value="0" name="XR_OBJECT_TYPE_UNKNOWN"/> + <enum value="1" name="XR_OBJECT_TYPE_INSTANCE" comment="XrInstance"/> + <enum value="2" name="XR_OBJECT_TYPE_SESSION" comment="XrSession"/> + <enum value="3" name="XR_OBJECT_TYPE_SWAPCHAIN" comment="XrSwapchain"/> + <enum value="4" name="XR_OBJECT_TYPE_SPACE" comment="XrSpace"/> + <enum value="5" name="XR_OBJECT_TYPE_ACTION_SET" comment="XrActionSet"/> + <enum value="6" name="XR_OBJECT_TYPE_ACTION" comment="XrAction"/> + </enums> + <enums name="XrAndroidThreadTypeKHR" type="enum" comment="Android Thread Types"> + <enum value="1" name="XR_ANDROID_THREAD_TYPE_APPLICATION_MAIN_KHR"/> + <enum value="2" name="XR_ANDROID_THREAD_TYPE_APPLICATION_WORKER_KHR"/> + <enum value="3" name="XR_ANDROID_THREAD_TYPE_RENDERER_MAIN_KHR"/> + <enum value="4" name="XR_ANDROID_THREAD_TYPE_RENDERER_WORKER_KHR"/> + </enums> + <enums name="XrEyeVisibility" type="enum" comment="eye visibility selector"> + <enum value="0" name="XR_EYE_VISIBILITY_BOTH" comment="Display in both eyes."/> + <enum value="1" name="XR_EYE_VISIBILITY_LEFT" comment="Display in the left eye only."/> + <enum value="2" name="XR_EYE_VISIBILITY_RIGHT" comment="Display in the right eye only."/> + </enums> + <enums name="XrActionType" type="enum"> + <enum value="1" name="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <enum value="2" name="XR_ACTION_TYPE_FLOAT_INPUT"/> + <enum value="3" name="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <enum value="4" name="XR_ACTION_TYPE_POSE_INPUT"/> + <enum value="100" name="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </enums> + <enums name="XrReferenceSpaceType" type="enum"> + <enum value="1" name="XR_REFERENCE_SPACE_TYPE_VIEW"/> + <enum value="2" name="XR_REFERENCE_SPACE_TYPE_LOCAL"/> + <enum value="3" name="XR_REFERENCE_SPACE_TYPE_STAGE"/> + </enums> + <enums name="XrFormFactor" type="enum"> + <enum value="1" name="XR_FORM_FACTOR_HEAD_MOUNTED_DISPLAY"/> + <enum value="2" name="XR_FORM_FACTOR_HANDHELD_DISPLAY"/> + </enums> + <enums name="XrViewConfigurationType" type="enum"> + <enum value="1" name="XR_VIEW_CONFIGURATION_TYPE_PRIMARY_MONO"/> + <enum value="2" name="XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO"/> + </enums> + <enums name="XrEnvironmentBlendMode" type="enum"> + <enum value="1" name="XR_ENVIRONMENT_BLEND_MODE_OPAQUE"/> + <enum value="2" name="XR_ENVIRONMENT_BLEND_MODE_ADDITIVE"/> + <enum value="3" name="XR_ENVIRONMENT_BLEND_MODE_ALPHA_BLEND"/> + </enums> + <enums name="XrSessionState" type="enum"> + <enum value="0" name="XR_SESSION_STATE_UNKNOWN"/> + <enum value="1" name="XR_SESSION_STATE_IDLE"/> + <enum value="2" name="XR_SESSION_STATE_READY"/> + <enum value="3" name="XR_SESSION_STATE_SYNCHRONIZED"/> + <enum value="4" name="XR_SESSION_STATE_VISIBLE"/> + <enum value="5" name="XR_SESSION_STATE_FOCUSED"/> + <enum value="6" name="XR_SESSION_STATE_STOPPING"/> + <enum value="7" name="XR_SESSION_STATE_LOSS_PENDING"/> + <enum value="8" name="XR_SESSION_STATE_EXITING"/> + </enums> + + <!--enums for Perf setting EXT--> + <enums name="XrPerfSettingsLevelEXT" type="enum"> + <enum value="0" name="XR_PERF_SETTINGS_LEVEL_POWER_SAVINGS_EXT" comment="Performance settings hint used by the application to indicate that it enters a non-XR section (head-locked / static screen), during which power savings are to be prioritized"/> + <enum value="25" name="XR_PERF_SETTINGS_LEVEL_SUSTAINED_LOW_EXT" comment="Performance settings hint used by the application to indicate that it enters a low and stable complexity section, during which reducing power is more important than occasional late rendering frames"/> + <enum value="50" name="XR_PERF_SETTINGS_LEVEL_SUSTAINED_HIGH_EXT" comment="Performance settings hint used by the application to indicate that it enters a high or dynamic complexity section, during which the XR Runtime strives for consistent XR compositing and frame rendering within a thermally sustainable range"/> + <enum value="75" name="XR_PERF_SETTINGS_LEVEL_BOOST_EXT" comment="Performance settings hint used by the application to indicate that the application enters a section with very high complexity, during which the XR Runtime is allowed to step up beyond the thermally sustainable range"/> + </enums> + <enums name="XrPerfSettingsDomainEXT" type="enum"> + <enum value="1" name="XR_PERF_SETTINGS_DOMAIN_CPU_EXT" comment="Indicates that the performance settings or notification applies to CPU domain"/> + <enum value="2" name="XR_PERF_SETTINGS_DOMAIN_GPU_EXT" comment="Indicates that the performance settings or notification applies to GPU domain"/> + </enums> + <enums name="XrPerfSettingsSubDomainEXT" type="enum"> + <enum value="1" name="XR_PERF_SETTINGS_SUB_DOMAIN_COMPOSITING_EXT" comment="Indicates that the performance notification originates from the COMPOSITING sub-domain"/> + <enum value="2" name="XR_PERF_SETTINGS_SUB_DOMAIN_RENDERING_EXT" comment="Indicates that the performance notification originates from the RENDERING sub-domain"/> + <enum value="3" name="XR_PERF_SETTINGS_SUB_DOMAIN_THERMAL_EXT" comment="Indicates that the performance notification originates from the THERMAL sub-domain"/> + </enums> + <enums name="XrPerfSettingsNotificationLevelEXT" type="enum"> + <enum value="0" name="XR_PERF_SETTINGS_NOTIF_LEVEL_NORMAL_EXT" comment="Notifies that the sub-domain has reached a level where no further actions other than currently applied are necessary"/> + <enum value="25" name="XR_PERF_SETTINGS_NOTIF_LEVEL_WARNING_EXT" comment="Notifies that the sub-domain has reached an early warning level where the application should start proactive mitigation actions with the goal to return to the ename:XR_PERF_NOTIF_LEVEL_NORMAL level"/> + <enum value="75" name="XR_PERF_SETTINGS_NOTIF_LEVEL_IMPAIRED_EXT" comment="Notifies that the sub-domain has reached a critical level with significant performance degradation. The application should take drastic mitigation action"/> + </enums> + + <!--enums for XR_KHR_visibility_mask --> + <enums name="XrVisibilityMaskTypeKHR" type="enum" comment=""> + <enum value="1" name="XR_VISIBILITY_MASK_TYPE_HIDDEN_TRIANGLE_MESH_KHR" comment="exclusive mesh; indicates that which the viewer cannot see."/> + <enum value="2" name="XR_VISIBILITY_MASK_TYPE_VISIBLE_TRIANGLE_MESH_KHR" comment="inclusive mesh; indicates strictly that which the viewer can see."/> + <enum value="3" name="XR_VISIBILITY_MASK_TYPE_LINE_LOOP_KHR" comment="line loop; traces the outline of the area the viewer can see."/> + </enums> + + <!-- XR_EXT_hand_tracking --> + <enums name="XrHandEXT" type="enum"> + <enum value="1" name="XR_HAND_LEFT_EXT"/> + <enum value="2" name="XR_HAND_RIGHT_EXT"/> + </enums> + <enums name="XrHandJointEXT" type="enum"> + <enum value="0" name="XR_HAND_JOINT_PALM_EXT"/> + <enum value="1" name="XR_HAND_JOINT_WRIST_EXT"/> + <enum value="2" name="XR_HAND_JOINT_THUMB_METACARPAL_EXT"/> + <enum value="3" name="XR_HAND_JOINT_THUMB_PROXIMAL_EXT"/> + <enum value="4" name="XR_HAND_JOINT_THUMB_DISTAL_EXT"/> + <enum value="5" name="XR_HAND_JOINT_THUMB_TIP_EXT"/> + <enum value="6" name="XR_HAND_JOINT_INDEX_METACARPAL_EXT"/> + <enum value="7" name="XR_HAND_JOINT_INDEX_PROXIMAL_EXT"/> + <enum value="8" name="XR_HAND_JOINT_INDEX_INTERMEDIATE_EXT"/> + <enum value="9" name="XR_HAND_JOINT_INDEX_DISTAL_EXT"/> + <enum value="10" name="XR_HAND_JOINT_INDEX_TIP_EXT"/> + <enum value="11" name="XR_HAND_JOINT_MIDDLE_METACARPAL_EXT"/> + <enum value="12" name="XR_HAND_JOINT_MIDDLE_PROXIMAL_EXT"/> + <enum value="13" name="XR_HAND_JOINT_MIDDLE_INTERMEDIATE_EXT"/> + <enum value="14" name="XR_HAND_JOINT_MIDDLE_DISTAL_EXT"/> + <enum value="15" name="XR_HAND_JOINT_MIDDLE_TIP_EXT"/> + <enum value="16" name="XR_HAND_JOINT_RING_METACARPAL_EXT"/> + <enum value="17" name="XR_HAND_JOINT_RING_PROXIMAL_EXT"/> + <enum value="18" name="XR_HAND_JOINT_RING_INTERMEDIATE_EXT"/> + <enum value="19" name="XR_HAND_JOINT_RING_DISTAL_EXT"/> + <enum value="20" name="XR_HAND_JOINT_RING_TIP_EXT"/> + <enum value="21" name="XR_HAND_JOINT_LITTLE_METACARPAL_EXT"/> + <enum value="22" name="XR_HAND_JOINT_LITTLE_PROXIMAL_EXT"/> + <enum value="23" name="XR_HAND_JOINT_LITTLE_INTERMEDIATE_EXT"/> + <enum value="24" name="XR_HAND_JOINT_LITTLE_DISTAL_EXT"/> + <enum value="25" name="XR_HAND_JOINT_LITTLE_TIP_EXT"/> + </enums> + <enums name="XrHandJointSetEXT" type="enum"> + <enum value="0" name="XR_HAND_JOINT_SET_DEFAULT_EXT"/> + </enums> + + <!-- XR_EXT_hand_joints_motion_range --> + <enums name="XrHandJointsMotionRangeEXT" type="enum"> + <enum value="1" name="XR_HAND_JOINTS_MOTION_RANGE_UNOBSTRUCTED_EXT"/> + <enum value="2" name="XR_HAND_JOINTS_MOTION_RANGE_CONFORMING_TO_CONTROLLER_EXT"/> + </enums> + + <!-- XR_EXT_hand_tracking_data_source --> + <enums name="XrHandTrackingDataSourceEXT" type="enum"> + <enum value="1" name="XR_HAND_TRACKING_DATA_SOURCE_UNOBSTRUCTED_EXT" comment="This data source value indicates individual fingers and joints are tracked from unobstructed data source such as optical hand tracking, data gloves, or motion capture devices."/> + <enum value="2" name="XR_HAND_TRACKING_DATA_SOURCE_CONTROLLER_EXT" comment="This data source value indicates hand joints are inferred based on motion controller state."/> + </enums> + + <!-- flags for XR_EXT_frame_synthesis --> + <enums name="XrFrameSynthesisInfoFlagBitsEXT" type="bitmask"> + <enum bitpos="0" name="XR_FRAME_SYNTHESIS_INFO_USE_2D_MOTION_VECTOR_BIT_EXT" comment="2D motion vector will be used"/> + <enum bitpos="1" name="XR_FRAME_SYNTHESIS_INFO_REQUEST_RELAXED_FRAME_INTERVAL_BIT_EXT" comment="Request the runtime to relax the application's frame interval to allow additional render time"/> + </enums> + + <!-- XR_MSFT_hand_tracking_mesh --> + <enums name="XrHandPoseTypeMSFT" type="enum"> + <enum value="0" name="XR_HAND_POSE_TYPE_TRACKED_MSFT"/> + <enum value="1" name="XR_HAND_POSE_TYPE_REFERENCE_OPEN_PALM_MSFT"/> + </enums> + + <!-- XR_FB_face_tracking --> + <enums name="XrFaceExpressionFB" type="enum"> + <enum value="0" name="XR_FACE_EXPRESSION_BROW_LOWERER_L_FB"/> + <enum value="1" name="XR_FACE_EXPRESSION_BROW_LOWERER_R_FB"/> + <enum value="2" name="XR_FACE_EXPRESSION_CHEEK_PUFF_L_FB"/> + <enum value="3" name="XR_FACE_EXPRESSION_CHEEK_PUFF_R_FB"/> + <enum value="4" name="XR_FACE_EXPRESSION_CHEEK_RAISER_L_FB"/> + <enum value="5" name="XR_FACE_EXPRESSION_CHEEK_RAISER_R_FB"/> + <enum value="6" name="XR_FACE_EXPRESSION_CHEEK_SUCK_L_FB"/> + <enum value="7" name="XR_FACE_EXPRESSION_CHEEK_SUCK_R_FB"/> + <enum value="8" name="XR_FACE_EXPRESSION_CHIN_RAISER_B_FB"/> + <enum value="9" name="XR_FACE_EXPRESSION_CHIN_RAISER_T_FB"/> + <enum value="10" name="XR_FACE_EXPRESSION_DIMPLER_L_FB"/> + <enum value="11" name="XR_FACE_EXPRESSION_DIMPLER_R_FB"/> + <enum value="12" name="XR_FACE_EXPRESSION_EYES_CLOSED_L_FB"/> + <enum value="13" name="XR_FACE_EXPRESSION_EYES_CLOSED_R_FB"/> + <enum value="14" name="XR_FACE_EXPRESSION_EYES_LOOK_DOWN_L_FB"/> + <enum value="15" name="XR_FACE_EXPRESSION_EYES_LOOK_DOWN_R_FB"/> + <enum value="16" name="XR_FACE_EXPRESSION_EYES_LOOK_LEFT_L_FB"/> + <enum value="17" name="XR_FACE_EXPRESSION_EYES_LOOK_LEFT_R_FB"/> + <enum value="18" name="XR_FACE_EXPRESSION_EYES_LOOK_RIGHT_L_FB"/> + <enum value="19" name="XR_FACE_EXPRESSION_EYES_LOOK_RIGHT_R_FB"/> + <enum value="20" name="XR_FACE_EXPRESSION_EYES_LOOK_UP_L_FB"/> + <enum value="21" name="XR_FACE_EXPRESSION_EYES_LOOK_UP_R_FB"/> + <enum value="22" name="XR_FACE_EXPRESSION_INNER_BROW_RAISER_L_FB"/> + <enum value="23" name="XR_FACE_EXPRESSION_INNER_BROW_RAISER_R_FB"/> + <enum value="24" name="XR_FACE_EXPRESSION_JAW_DROP_FB"/> + <enum value="25" name="XR_FACE_EXPRESSION_JAW_SIDEWAYS_LEFT_FB"/> + <enum value="26" name="XR_FACE_EXPRESSION_JAW_SIDEWAYS_RIGHT_FB"/> + <enum value="27" name="XR_FACE_EXPRESSION_JAW_THRUST_FB"/> + <enum value="28" name="XR_FACE_EXPRESSION_LID_TIGHTENER_L_FB"/> + <enum value="29" name="XR_FACE_EXPRESSION_LID_TIGHTENER_R_FB"/> + <enum value="30" name="XR_FACE_EXPRESSION_LIP_CORNER_DEPRESSOR_L_FB"/> + <enum value="31" name="XR_FACE_EXPRESSION_LIP_CORNER_DEPRESSOR_R_FB"/> + <enum value="32" name="XR_FACE_EXPRESSION_LIP_CORNER_PULLER_L_FB"/> + <enum value="33" name="XR_FACE_EXPRESSION_LIP_CORNER_PULLER_R_FB"/> + <enum value="34" name="XR_FACE_EXPRESSION_LIP_FUNNELER_LB_FB"/> + <enum value="35" name="XR_FACE_EXPRESSION_LIP_FUNNELER_LT_FB"/> + <enum value="36" name="XR_FACE_EXPRESSION_LIP_FUNNELER_RB_FB"/> + <enum value="37" name="XR_FACE_EXPRESSION_LIP_FUNNELER_RT_FB"/> + <enum value="38" name="XR_FACE_EXPRESSION_LIP_PRESSOR_L_FB"/> + <enum value="39" name="XR_FACE_EXPRESSION_LIP_PRESSOR_R_FB"/> + <enum value="40" name="XR_FACE_EXPRESSION_LIP_PUCKER_L_FB"/> + <enum value="41" name="XR_FACE_EXPRESSION_LIP_PUCKER_R_FB"/> + <enum value="42" name="XR_FACE_EXPRESSION_LIP_STRETCHER_L_FB"/> + <enum value="43" name="XR_FACE_EXPRESSION_LIP_STRETCHER_R_FB"/> + <enum value="44" name="XR_FACE_EXPRESSION_LIP_SUCK_LB_FB"/> + <enum value="45" name="XR_FACE_EXPRESSION_LIP_SUCK_LT_FB"/> + <enum value="46" name="XR_FACE_EXPRESSION_LIP_SUCK_RB_FB"/> + <enum value="47" name="XR_FACE_EXPRESSION_LIP_SUCK_RT_FB"/> + <enum value="48" name="XR_FACE_EXPRESSION_LIP_TIGHTENER_L_FB"/> + <enum value="49" name="XR_FACE_EXPRESSION_LIP_TIGHTENER_R_FB"/> + <enum value="50" name="XR_FACE_EXPRESSION_LIPS_TOWARD_FB"/> + <enum value="51" name="XR_FACE_EXPRESSION_LOWER_LIP_DEPRESSOR_L_FB"/> + <enum value="52" name="XR_FACE_EXPRESSION_LOWER_LIP_DEPRESSOR_R_FB"/> + <enum value="53" name="XR_FACE_EXPRESSION_MOUTH_LEFT_FB"/> + <enum value="54" name="XR_FACE_EXPRESSION_MOUTH_RIGHT_FB"/> + <enum value="55" name="XR_FACE_EXPRESSION_NOSE_WRINKLER_L_FB"/> + <enum value="56" name="XR_FACE_EXPRESSION_NOSE_WRINKLER_R_FB"/> + <enum value="57" name="XR_FACE_EXPRESSION_OUTER_BROW_RAISER_L_FB"/> + <enum value="58" name="XR_FACE_EXPRESSION_OUTER_BROW_RAISER_R_FB"/> + <enum value="59" name="XR_FACE_EXPRESSION_UPPER_LID_RAISER_L_FB"/> + <enum value="60" name="XR_FACE_EXPRESSION_UPPER_LID_RAISER_R_FB"/> + <enum value="61" name="XR_FACE_EXPRESSION_UPPER_LIP_RAISER_L_FB"/> + <enum value="62" name="XR_FACE_EXPRESSION_UPPER_LIP_RAISER_R_FB"/> + <enum value="63" name="XR_FACE_EXPRESSION_COUNT_FB"/> + </enums> + + <enums name="XrFaceExpressionSetFB" type="enum"> + <enum value="0" name="XR_FACE_EXPRESSION_SET_DEFAULT_FB" comment="indicates that the created slink:XrFaceTrackerFB tracks the set of blend shapes described by elink:XrFaceExpressionFB enum, i.e. the flink:xrGetFaceExpressionWeightsFB function returns an array of blend shapes with the count of ename:XR_FACE_EXPRESSION_COUNT_FB and can: be indexed using elink:XrFaceExpressionFB."/> + </enums> + <enums name="XrFaceConfidenceFB" type="enum"> + <enum value="0" name="XR_FACE_CONFIDENCE_LOWER_FACE_FB"/> + <enum value="1" name="XR_FACE_CONFIDENCE_UPPER_FACE_FB"/> + <enum value="2" name="XR_FACE_CONFIDENCE_COUNT_FB"/> + </enums> + + <!-- XR_FB_face_tracking2 --> + <enums name="XrFaceExpression2FB" type="enum"> + <enum value="0" name="XR_FACE_EXPRESSION2_BROW_LOWERER_L_FB"/> + <enum value="1" name="XR_FACE_EXPRESSION2_BROW_LOWERER_R_FB"/> + <enum value="2" name="XR_FACE_EXPRESSION2_CHEEK_PUFF_L_FB"/> + <enum value="3" name="XR_FACE_EXPRESSION2_CHEEK_PUFF_R_FB"/> + <enum value="4" name="XR_FACE_EXPRESSION2_CHEEK_RAISER_L_FB"/> + <enum value="5" name="XR_FACE_EXPRESSION2_CHEEK_RAISER_R_FB"/> + <enum value="6" name="XR_FACE_EXPRESSION2_CHEEK_SUCK_L_FB"/> + <enum value="7" name="XR_FACE_EXPRESSION2_CHEEK_SUCK_R_FB"/> + <enum value="8" name="XR_FACE_EXPRESSION2_CHIN_RAISER_B_FB"/> + <enum value="9" name="XR_FACE_EXPRESSION2_CHIN_RAISER_T_FB"/> + <enum value="10" name="XR_FACE_EXPRESSION2_DIMPLER_L_FB"/> + <enum value="11" name="XR_FACE_EXPRESSION2_DIMPLER_R_FB"/> + <enum value="12" name="XR_FACE_EXPRESSION2_EYES_CLOSED_L_FB"/> + <enum value="13" name="XR_FACE_EXPRESSION2_EYES_CLOSED_R_FB"/> + <enum value="14" name="XR_FACE_EXPRESSION2_EYES_LOOK_DOWN_L_FB"/> + <enum value="15" name="XR_FACE_EXPRESSION2_EYES_LOOK_DOWN_R_FB"/> + <enum value="16" name="XR_FACE_EXPRESSION2_EYES_LOOK_LEFT_L_FB"/> + <enum value="17" name="XR_FACE_EXPRESSION2_EYES_LOOK_LEFT_R_FB"/> + <enum value="18" name="XR_FACE_EXPRESSION2_EYES_LOOK_RIGHT_L_FB"/> + <enum value="19" name="XR_FACE_EXPRESSION2_EYES_LOOK_RIGHT_R_FB"/> + <enum value="20" name="XR_FACE_EXPRESSION2_EYES_LOOK_UP_L_FB"/> + <enum value="21" name="XR_FACE_EXPRESSION2_EYES_LOOK_UP_R_FB"/> + <enum value="22" name="XR_FACE_EXPRESSION2_INNER_BROW_RAISER_L_FB"/> + <enum value="23" name="XR_FACE_EXPRESSION2_INNER_BROW_RAISER_R_FB"/> + <enum value="24" name="XR_FACE_EXPRESSION2_JAW_DROP_FB"/> + <enum value="25" name="XR_FACE_EXPRESSION2_JAW_SIDEWAYS_LEFT_FB"/> + <enum value="26" name="XR_FACE_EXPRESSION2_JAW_SIDEWAYS_RIGHT_FB"/> + <enum value="27" name="XR_FACE_EXPRESSION2_JAW_THRUST_FB"/> + <enum value="28" name="XR_FACE_EXPRESSION2_LID_TIGHTENER_L_FB"/> + <enum value="29" name="XR_FACE_EXPRESSION2_LID_TIGHTENER_R_FB"/> + <enum value="30" name="XR_FACE_EXPRESSION2_LIP_CORNER_DEPRESSOR_L_FB"/> + <enum value="31" name="XR_FACE_EXPRESSION2_LIP_CORNER_DEPRESSOR_R_FB"/> + <enum value="32" name="XR_FACE_EXPRESSION2_LIP_CORNER_PULLER_L_FB"/> + <enum value="33" name="XR_FACE_EXPRESSION2_LIP_CORNER_PULLER_R_FB"/> + <enum value="34" name="XR_FACE_EXPRESSION2_LIP_FUNNELER_LB_FB"/> + <enum value="35" name="XR_FACE_EXPRESSION2_LIP_FUNNELER_LT_FB"/> + <enum value="36" name="XR_FACE_EXPRESSION2_LIP_FUNNELER_RB_FB"/> + <enum value="37" name="XR_FACE_EXPRESSION2_LIP_FUNNELER_RT_FB"/> + <enum value="38" name="XR_FACE_EXPRESSION2_LIP_PRESSOR_L_FB"/> + <enum value="39" name="XR_FACE_EXPRESSION2_LIP_PRESSOR_R_FB"/> + <enum value="40" name="XR_FACE_EXPRESSION2_LIP_PUCKER_L_FB"/> + <enum value="41" name="XR_FACE_EXPRESSION2_LIP_PUCKER_R_FB"/> + <enum value="42" name="XR_FACE_EXPRESSION2_LIP_STRETCHER_L_FB"/> + <enum value="43" name="XR_FACE_EXPRESSION2_LIP_STRETCHER_R_FB"/> + <enum value="44" name="XR_FACE_EXPRESSION2_LIP_SUCK_LB_FB"/> + <enum value="45" name="XR_FACE_EXPRESSION2_LIP_SUCK_LT_FB"/> + <enum value="46" name="XR_FACE_EXPRESSION2_LIP_SUCK_RB_FB"/> + <enum value="47" name="XR_FACE_EXPRESSION2_LIP_SUCK_RT_FB"/> + <enum value="48" name="XR_FACE_EXPRESSION2_LIP_TIGHTENER_L_FB"/> + <enum value="49" name="XR_FACE_EXPRESSION2_LIP_TIGHTENER_R_FB"/> + <enum value="50" name="XR_FACE_EXPRESSION2_LIPS_TOWARD_FB"/> + <enum value="51" name="XR_FACE_EXPRESSION2_LOWER_LIP_DEPRESSOR_L_FB"/> + <enum value="52" name="XR_FACE_EXPRESSION2_LOWER_LIP_DEPRESSOR_R_FB"/> + <enum value="53" name="XR_FACE_EXPRESSION2_MOUTH_LEFT_FB"/> + <enum value="54" name="XR_FACE_EXPRESSION2_MOUTH_RIGHT_FB"/> + <enum value="55" name="XR_FACE_EXPRESSION2_NOSE_WRINKLER_L_FB"/> + <enum value="56" name="XR_FACE_EXPRESSION2_NOSE_WRINKLER_R_FB"/> + <enum value="57" name="XR_FACE_EXPRESSION2_OUTER_BROW_RAISER_L_FB"/> + <enum value="58" name="XR_FACE_EXPRESSION2_OUTER_BROW_RAISER_R_FB"/> + <enum value="59" name="XR_FACE_EXPRESSION2_UPPER_LID_RAISER_L_FB"/> + <enum value="60" name="XR_FACE_EXPRESSION2_UPPER_LID_RAISER_R_FB"/> + <enum value="61" name="XR_FACE_EXPRESSION2_UPPER_LIP_RAISER_L_FB"/> + <enum value="62" name="XR_FACE_EXPRESSION2_UPPER_LIP_RAISER_R_FB"/> + <enum value="63" name="XR_FACE_EXPRESSION2_TONGUE_TIP_INTERDENTAL_FB"/> + <enum value="64" name="XR_FACE_EXPRESSION2_TONGUE_TIP_ALVEOLAR_FB"/> + <enum value="65" name="XR_FACE_EXPRESSION2_TONGUE_FRONT_DORSAL_PALATE_FB"/> + <enum value="66" name="XR_FACE_EXPRESSION2_TONGUE_MID_DORSAL_PALATE_FB"/> + <enum value="67" name="XR_FACE_EXPRESSION2_TONGUE_BACK_DORSAL_VELAR_FB"/> + <enum value="68" name="XR_FACE_EXPRESSION2_TONGUE_OUT_FB"/> + <enum value="69" name="XR_FACE_EXPRESSION2_TONGUE_RETREAT_FB"/> + <enum value="70" name="XR_FACE_EXPRESSION2_COUNT_FB"/> + </enums> + + <enums name="XrFaceExpressionSet2FB" type="enum"> + <enum value="0" name="XR_FACE_EXPRESSION_SET2_DEFAULT_FB" comment="indicates that the created slink:XrFaceTracker2FB tracks the set of blend shapes described by elink:XrFaceExpression2FB enum, i.e. the flink:xrGetFaceExpressionWeights2FB function returns an array of blend shapes with the count of ename:XR_FACE_EXPRESSION2_COUNT_FB and can: be indexed using elink:XrFaceExpression2FB."/> + </enums> + <enums name="XrFaceTrackingDataSource2FB" type="enum"> + <enum value="0" name="XR_FACE_TRACKING_DATA_SOURCE2_VISUAL_FB" comment="face tracking uses visual data to estimate expressions. Face tracking may use audio to further improve the quality of face tracking."/> + <enum value="1" name="XR_FACE_TRACKING_DATA_SOURCE2_AUDIO_FB" comment="face tracking uses audio data to estimate expressions."/> + </enums> + <enums name="XrFaceConfidence2FB" type="enum"> + <enum value="0" name="XR_FACE_CONFIDENCE2_LOWER_FACE_FB"/> + <enum value="1" name="XR_FACE_CONFIDENCE2_UPPER_FACE_FB"/> + <enum value="2" name="XR_FACE_CONFIDENCE2_COUNT_FB"/> + </enums> + + <!-- XR_META_face_tracking_visemes --> + <enums name="XrFaceTrackingVisemeMETA" type="enum"> + <enum value="0" name="XR_FACE_TRACKING_VISEME_SIL_META"/> + <enum value="1" name="XR_FACE_TRACKING_VISEME_PP_META"/> + <enum value="2" name="XR_FACE_TRACKING_VISEME_FF_META"/> + <enum value="3" name="XR_FACE_TRACKING_VISEME_TH_META"/> + <enum value="4" name="XR_FACE_TRACKING_VISEME_DD_META"/> + <enum value="5" name="XR_FACE_TRACKING_VISEME_KK_META"/> + <enum value="6" name="XR_FACE_TRACKING_VISEME_CH_META"/> + <enum value="7" name="XR_FACE_TRACKING_VISEME_SS_META"/> + <enum value="8" name="XR_FACE_TRACKING_VISEME_NN_META"/> + <enum value="9" name="XR_FACE_TRACKING_VISEME_RR_META"/> + <enum value="10" name="XR_FACE_TRACKING_VISEME_AA_META"/> + <enum value="11" name="XR_FACE_TRACKING_VISEME_E_META"/> + <enum value="12" name="XR_FACE_TRACKING_VISEME_IH_META"/> + <enum value="13" name="XR_FACE_TRACKING_VISEME_OH_META"/> + <enum value="14" name="XR_FACE_TRACKING_VISEME_OU_META"/> + </enums> + + <!-- XR_FB_body_tracking --> + <enums name="XrBodyJointFB" type="enum"> + <enum value="0" name="XR_BODY_JOINT_ROOT_FB"/> + <enum value="1" name="XR_BODY_JOINT_HIPS_FB"/> + <enum value="2" name="XR_BODY_JOINT_SPINE_LOWER_FB"/> + <enum value="3" name="XR_BODY_JOINT_SPINE_MIDDLE_FB"/> + <enum value="4" name="XR_BODY_JOINT_SPINE_UPPER_FB"/> + <enum value="5" name="XR_BODY_JOINT_CHEST_FB"/> + <enum value="6" name="XR_BODY_JOINT_NECK_FB"/> + <enum value="7" name="XR_BODY_JOINT_HEAD_FB"/> + <enum value="8" name="XR_BODY_JOINT_LEFT_SHOULDER_FB"/> + <enum value="9" name="XR_BODY_JOINT_LEFT_SCAPULA_FB"/> + <enum value="10" name="XR_BODY_JOINT_LEFT_ARM_UPPER_FB"/> + <enum value="11" name="XR_BODY_JOINT_LEFT_ARM_LOWER_FB"/> + <enum value="12" name="XR_BODY_JOINT_LEFT_HAND_WRIST_TWIST_FB"/> + <enum value="13" name="XR_BODY_JOINT_RIGHT_SHOULDER_FB"/> + <enum value="14" name="XR_BODY_JOINT_RIGHT_SCAPULA_FB"/> + <enum value="15" name="XR_BODY_JOINT_RIGHT_ARM_UPPER_FB"/> + <enum value="16" name="XR_BODY_JOINT_RIGHT_ARM_LOWER_FB"/> + <enum value="17" name="XR_BODY_JOINT_RIGHT_HAND_WRIST_TWIST_FB"/> + <enum value="18" name="XR_BODY_JOINT_LEFT_HAND_PALM_FB"/> + <enum value="19" name="XR_BODY_JOINT_LEFT_HAND_WRIST_FB"/> + <enum value="20" name="XR_BODY_JOINT_LEFT_HAND_THUMB_METACARPAL_FB"/> + <enum value="21" name="XR_BODY_JOINT_LEFT_HAND_THUMB_PROXIMAL_FB"/> + <enum value="22" name="XR_BODY_JOINT_LEFT_HAND_THUMB_DISTAL_FB"/> + <enum value="23" name="XR_BODY_JOINT_LEFT_HAND_THUMB_TIP_FB"/> + <enum value="24" name="XR_BODY_JOINT_LEFT_HAND_INDEX_METACARPAL_FB"/> + <enum value="25" name="XR_BODY_JOINT_LEFT_HAND_INDEX_PROXIMAL_FB"/> + <enum value="26" name="XR_BODY_JOINT_LEFT_HAND_INDEX_INTERMEDIATE_FB"/> + <enum value="27" name="XR_BODY_JOINT_LEFT_HAND_INDEX_DISTAL_FB"/> + <enum value="28" name="XR_BODY_JOINT_LEFT_HAND_INDEX_TIP_FB"/> + <enum value="29" name="XR_BODY_JOINT_LEFT_HAND_MIDDLE_METACARPAL_FB"/> + <enum value="30" name="XR_BODY_JOINT_LEFT_HAND_MIDDLE_PROXIMAL_FB"/> + <enum value="31" name="XR_BODY_JOINT_LEFT_HAND_MIDDLE_INTERMEDIATE_FB"/> + <enum value="32" name="XR_BODY_JOINT_LEFT_HAND_MIDDLE_DISTAL_FB"/> + <enum value="33" name="XR_BODY_JOINT_LEFT_HAND_MIDDLE_TIP_FB"/> + <enum value="34" name="XR_BODY_JOINT_LEFT_HAND_RING_METACARPAL_FB"/> + <enum value="35" name="XR_BODY_JOINT_LEFT_HAND_RING_PROXIMAL_FB"/> + <enum value="36" name="XR_BODY_JOINT_LEFT_HAND_RING_INTERMEDIATE_FB"/> + <enum value="37" name="XR_BODY_JOINT_LEFT_HAND_RING_DISTAL_FB"/> + <enum value="38" name="XR_BODY_JOINT_LEFT_HAND_RING_TIP_FB"/> + <enum value="39" name="XR_BODY_JOINT_LEFT_HAND_LITTLE_METACARPAL_FB"/> + <enum value="40" name="XR_BODY_JOINT_LEFT_HAND_LITTLE_PROXIMAL_FB"/> + <enum value="41" name="XR_BODY_JOINT_LEFT_HAND_LITTLE_INTERMEDIATE_FB"/> + <enum value="42" name="XR_BODY_JOINT_LEFT_HAND_LITTLE_DISTAL_FB"/> + <enum value="43" name="XR_BODY_JOINT_LEFT_HAND_LITTLE_TIP_FB"/> + <enum value="44" name="XR_BODY_JOINT_RIGHT_HAND_PALM_FB"/> + <enum value="45" name="XR_BODY_JOINT_RIGHT_HAND_WRIST_FB"/> + <enum value="46" name="XR_BODY_JOINT_RIGHT_HAND_THUMB_METACARPAL_FB"/> + <enum value="47" name="XR_BODY_JOINT_RIGHT_HAND_THUMB_PROXIMAL_FB"/> + <enum value="48" name="XR_BODY_JOINT_RIGHT_HAND_THUMB_DISTAL_FB"/> + <enum value="49" name="XR_BODY_JOINT_RIGHT_HAND_THUMB_TIP_FB"/> + <enum value="50" name="XR_BODY_JOINT_RIGHT_HAND_INDEX_METACARPAL_FB"/> + <enum value="51" name="XR_BODY_JOINT_RIGHT_HAND_INDEX_PROXIMAL_FB"/> + <enum value="52" name="XR_BODY_JOINT_RIGHT_HAND_INDEX_INTERMEDIATE_FB"/> + <enum value="53" name="XR_BODY_JOINT_RIGHT_HAND_INDEX_DISTAL_FB"/> + <enum value="54" name="XR_BODY_JOINT_RIGHT_HAND_INDEX_TIP_FB"/> + <enum value="55" name="XR_BODY_JOINT_RIGHT_HAND_MIDDLE_METACARPAL_FB"/> + <enum value="56" name="XR_BODY_JOINT_RIGHT_HAND_MIDDLE_PROXIMAL_FB"/> + <enum value="57" name="XR_BODY_JOINT_RIGHT_HAND_MIDDLE_INTERMEDIATE_FB"/> + <enum value="58" name="XR_BODY_JOINT_RIGHT_HAND_MIDDLE_DISTAL_FB"/> + <enum value="59" name="XR_BODY_JOINT_RIGHT_HAND_MIDDLE_TIP_FB"/> + <enum value="60" name="XR_BODY_JOINT_RIGHT_HAND_RING_METACARPAL_FB"/> + <enum value="61" name="XR_BODY_JOINT_RIGHT_HAND_RING_PROXIMAL_FB"/> + <enum value="62" name="XR_BODY_JOINT_RIGHT_HAND_RING_INTERMEDIATE_FB"/> + <enum value="63" name="XR_BODY_JOINT_RIGHT_HAND_RING_DISTAL_FB"/> + <enum value="64" name="XR_BODY_JOINT_RIGHT_HAND_RING_TIP_FB"/> + <enum value="65" name="XR_BODY_JOINT_RIGHT_HAND_LITTLE_METACARPAL_FB"/> + <enum value="66" name="XR_BODY_JOINT_RIGHT_HAND_LITTLE_PROXIMAL_FB"/> + <enum value="67" name="XR_BODY_JOINT_RIGHT_HAND_LITTLE_INTERMEDIATE_FB"/> + <enum value="68" name="XR_BODY_JOINT_RIGHT_HAND_LITTLE_DISTAL_FB"/> + <enum value="69" name="XR_BODY_JOINT_RIGHT_HAND_LITTLE_TIP_FB"/> + <enum value="70" name="XR_BODY_JOINT_COUNT_FB"/> + <enum value="-1" name="XR_BODY_JOINT_NONE_FB"/> + </enums> + + <enums name="XrBodyJointSetFB" type="enum" comment="Describes the set of body joints to track when creating an slink:XrBodyTrackerFB."> + <enum value="0" name="XR_BODY_JOINT_SET_DEFAULT_FB" comment="Indicates that the created slink:XrBodyTrackerFB tracks the set of body joints described by elink:XrBodyJointFB enum, i.e. the flink:xrLocateBodyJointsFB function returns an array of joint locations with the count of ename:XR_BODY_JOINT_COUNT_FB and can be indexed using elink:XrBodyJointFB. This includes the upper body, both hands, and torso."/> + </enums> + + <!-- XR_META_body_tracking_full_body --> + <enums name="XrFullBodyJointMETA" type="enum"> + <enum value="0" name="XR_FULL_BODY_JOINT_ROOT_META"/> + <enum value="1" name="XR_FULL_BODY_JOINT_HIPS_META"/> + <enum value="2" name="XR_FULL_BODY_JOINT_SPINE_LOWER_META"/> + <enum value="3" name="XR_FULL_BODY_JOINT_SPINE_MIDDLE_META"/> + <enum value="4" name="XR_FULL_BODY_JOINT_SPINE_UPPER_META"/> + <enum value="5" name="XR_FULL_BODY_JOINT_CHEST_META"/> + <enum value="6" name="XR_FULL_BODY_JOINT_NECK_META"/> + <enum value="7" name="XR_FULL_BODY_JOINT_HEAD_META"/> + <enum value="8" name="XR_FULL_BODY_JOINT_LEFT_SHOULDER_META"/> + <enum value="9" name="XR_FULL_BODY_JOINT_LEFT_SCAPULA_META"/> + <enum value="10" name="XR_FULL_BODY_JOINT_LEFT_ARM_UPPER_META"/> + <enum value="11" name="XR_FULL_BODY_JOINT_LEFT_ARM_LOWER_META"/> + <enum value="12" name="XR_FULL_BODY_JOINT_LEFT_HAND_WRIST_TWIST_META"/> + <enum value="13" name="XR_FULL_BODY_JOINT_RIGHT_SHOULDER_META"/> + <enum value="14" name="XR_FULL_BODY_JOINT_RIGHT_SCAPULA_META"/> + <enum value="15" name="XR_FULL_BODY_JOINT_RIGHT_ARM_UPPER_META"/> + <enum value="16" name="XR_FULL_BODY_JOINT_RIGHT_ARM_LOWER_META"/> + <enum value="17" name="XR_FULL_BODY_JOINT_RIGHT_HAND_WRIST_TWIST_META"/> + <enum value="18" name="XR_FULL_BODY_JOINT_LEFT_HAND_PALM_META"/> + <enum value="19" name="XR_FULL_BODY_JOINT_LEFT_HAND_WRIST_META"/> + <enum value="20" name="XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_METACARPAL_META"/> + <enum value="21" name="XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_PROXIMAL_META"/> + <enum value="22" name="XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_DISTAL_META"/> + <enum value="23" name="XR_FULL_BODY_JOINT_LEFT_HAND_THUMB_TIP_META"/> + <enum value="24" name="XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_METACARPAL_META"/> + <enum value="25" name="XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_PROXIMAL_META"/> + <enum value="26" name="XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_INTERMEDIATE_META"/> + <enum value="27" name="XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_DISTAL_META"/> + <enum value="28" name="XR_FULL_BODY_JOINT_LEFT_HAND_INDEX_TIP_META"/> + <enum value="29" name="XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_METACARPAL_META"/> + <enum value="30" name="XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_PROXIMAL_META"/> + <enum value="31" name="XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_INTERMEDIATE_META"/> + <enum value="32" name="XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_DISTAL_META"/> + <enum value="33" name="XR_FULL_BODY_JOINT_LEFT_HAND_MIDDLE_TIP_META"/> + <enum value="34" name="XR_FULL_BODY_JOINT_LEFT_HAND_RING_METACARPAL_META"/> + <enum value="35" name="XR_FULL_BODY_JOINT_LEFT_HAND_RING_PROXIMAL_META"/> + <enum value="36" name="XR_FULL_BODY_JOINT_LEFT_HAND_RING_INTERMEDIATE_META"/> + <enum value="37" name="XR_FULL_BODY_JOINT_LEFT_HAND_RING_DISTAL_META"/> + <enum value="38" name="XR_FULL_BODY_JOINT_LEFT_HAND_RING_TIP_META"/> + <enum value="39" name="XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_METACARPAL_META"/> + <enum value="40" name="XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_PROXIMAL_META"/> + <enum value="41" name="XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_INTERMEDIATE_META"/> + <enum value="42" name="XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_DISTAL_META"/> + <enum value="43" name="XR_FULL_BODY_JOINT_LEFT_HAND_LITTLE_TIP_META"/> + <enum value="44" name="XR_FULL_BODY_JOINT_RIGHT_HAND_PALM_META"/> + <enum value="45" name="XR_FULL_BODY_JOINT_RIGHT_HAND_WRIST_META"/> + <enum value="46" name="XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_METACARPAL_META"/> + <enum value="47" name="XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_PROXIMAL_META"/> + <enum value="48" name="XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_DISTAL_META"/> + <enum value="49" name="XR_FULL_BODY_JOINT_RIGHT_HAND_THUMB_TIP_META"/> + <enum value="50" name="XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_METACARPAL_META"/> + <enum value="51" name="XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_PROXIMAL_META"/> + <enum value="52" name="XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_INTERMEDIATE_META"/> + <enum value="53" name="XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_DISTAL_META"/> + <enum value="54" name="XR_FULL_BODY_JOINT_RIGHT_HAND_INDEX_TIP_META"/> + <enum value="55" name="XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_METACARPAL_META"/> + <enum value="56" name="XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_PROXIMAL_META"/> + <enum value="57" name="XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_INTERMEDIATE_META"/> + <enum value="58" name="XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_DISTAL_META"/> + <enum value="59" name="XR_FULL_BODY_JOINT_RIGHT_HAND_MIDDLE_TIP_META"/> + <enum value="60" name="XR_FULL_BODY_JOINT_RIGHT_HAND_RING_METACARPAL_META"/> + <enum value="61" name="XR_FULL_BODY_JOINT_RIGHT_HAND_RING_PROXIMAL_META"/> + <enum value="62" name="XR_FULL_BODY_JOINT_RIGHT_HAND_RING_INTERMEDIATE_META"/> + <enum value="63" name="XR_FULL_BODY_JOINT_RIGHT_HAND_RING_DISTAL_META"/> + <enum value="64" name="XR_FULL_BODY_JOINT_RIGHT_HAND_RING_TIP_META"/> + <enum value="65" name="XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_METACARPAL_META"/> + <enum value="66" name="XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_PROXIMAL_META"/> + <enum value="67" name="XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_INTERMEDIATE_META"/> + <enum value="68" name="XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_DISTAL_META"/> + <enum value="69" name="XR_FULL_BODY_JOINT_RIGHT_HAND_LITTLE_TIP_META"/> + <enum value="70" name="XR_FULL_BODY_JOINT_LEFT_UPPER_LEG_META"/> + <enum value="71" name="XR_FULL_BODY_JOINT_LEFT_LOWER_LEG_META"/> + <enum value="72" name="XR_FULL_BODY_JOINT_LEFT_FOOT_ANKLE_TWIST_META"/> + <enum value="73" name="XR_FULL_BODY_JOINT_LEFT_FOOT_ANKLE_META"/> + <enum value="74" name="XR_FULL_BODY_JOINT_LEFT_FOOT_SUBTALAR_META"/> + <enum value="75" name="XR_FULL_BODY_JOINT_LEFT_FOOT_TRANSVERSE_META"/> + <enum value="76" name="XR_FULL_BODY_JOINT_LEFT_FOOT_BALL_META"/> + <enum value="77" name="XR_FULL_BODY_JOINT_RIGHT_UPPER_LEG_META"/> + <enum value="78" name="XR_FULL_BODY_JOINT_RIGHT_LOWER_LEG_META"/> + <enum value="79" name="XR_FULL_BODY_JOINT_RIGHT_FOOT_ANKLE_TWIST_META"/> + <enum value="80" name="XR_FULL_BODY_JOINT_RIGHT_FOOT_ANKLE_META"/> + <enum value="81" name="XR_FULL_BODY_JOINT_RIGHT_FOOT_SUBTALAR_META"/> + <enum value="82" name="XR_FULL_BODY_JOINT_RIGHT_FOOT_TRANSVERSE_META"/> + <enum value="83" name="XR_FULL_BODY_JOINT_RIGHT_FOOT_BALL_META"/> + <enum value="84" name="XR_FULL_BODY_JOINT_COUNT_META"/> + + <!-- used as a sentinel value for root-parent joint --> + <enum value="85" name="XR_FULL_BODY_JOINT_NONE_META"/> + </enums> + + <!-- XR_META_body_tracking_calibration --> + <enums name="XrBodyTrackingCalibrationStateMETA" type="enum"> + <enum value="1" name="XR_BODY_TRACKING_CALIBRATION_STATE_VALID_META" comment="Valid calibration, body tracking expected to be stable."/> + <enum value="2" name="XR_BODY_TRACKING_CALIBRATION_STATE_CALIBRATING_META" comment="Calibration is in progress, body joint poses from ename:XR_FB_body_tracking are valid to read and internally consistent within a single call, but may: be more variable than normal, shifting dramatically before calibration ends."/> + <enum value="3" name="XR_BODY_TRACKING_CALIBRATION_STATE_INVALID_META" comment="Calibration is invalid, accessing the body joint poses from ename:XR_FB_body_tracking is defined behavior but their contents are unspecified. Tracking data may: be read but must: not be interpreted as body tracking poses."/> + </enums> + + <!-- XR_META_body_tracking_fidelity --> + <enums name="XrBodyTrackingFidelityMETA" type="enum"> + <enum value="1" name="XR_BODY_TRACKING_FIDELITY_LOW_META" comment="This value indicates that the body tracking runtime uses a simpler algorithm or less input to estimate the body pose in a way that trades off pose quality for system performance. For example, low fidelity may not accurately track a user's elbows."/> + <enum value="2" name="XR_BODY_TRACKING_FIDELITY_HIGH_META" comment="This value indicates that the body tracking runtime uses more advanced algorithms or more inputs to estimate the body pose. For example high fidelity may track a user's elbows."/> + </enums> + + <!-- XR_FB_eye_tracking_social --> + <enums name="XrEyePositionFB" type="enum"> + <enum value="0" name="XR_EYE_POSITION_LEFT_FB" comment="Specifies the position of the left eye."/> + <enum value="1" name="XR_EYE_POSITION_RIGHT_FB" comment="Specifies the position of the right eye."/> + <enum value="2" name="XR_EYE_POSITION_COUNT_FB" comment="Specifies the number of eyes tracked."/> + </enums> + + <!-- XR_FB_color_space --> + <enums name="XrColorSpaceFB" type="enum"> + <enum value="0" name="XR_COLOR_SPACE_UNMANAGED_FB"/> + <enum value="1" name="XR_COLOR_SPACE_REC2020_FB"/> + <enum value="2" name="XR_COLOR_SPACE_REC709_FB"/> + <enum value="3" name="XR_COLOR_SPACE_RIFT_CV1_FB"/> + <enum value="4" name="XR_COLOR_SPACE_RIFT_S_FB"/> + <enum value="5" name="XR_COLOR_SPACE_QUEST_FB"/> + <enum value="6" name="XR_COLOR_SPACE_P3_FB"/> + <enum value="7" name="XR_COLOR_SPACE_ADOBE_RGB_FB"/> + </enums> + + <!-- XR_FB_composition_layer_alpha_blend --> + <enums name="XrBlendFactorFB" type="enum"> + <enum value="0" name="XR_BLEND_FACTOR_ZERO_FB"/> + <enum value="1" name="XR_BLEND_FACTOR_ONE_FB"/> + <enum value="2" name="XR_BLEND_FACTOR_SRC_ALPHA_FB"/> + <enum value="3" name="XR_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA_FB"/> + <enum value="4" name="XR_BLEND_FACTOR_DST_ALPHA_FB"/> + <enum value="5" name="XR_BLEND_FACTOR_ONE_MINUS_DST_ALPHA_FB"/> + </enums> + + <!-- XR_MSFT_composition_layer_reprojection --> + <enums name="XrReprojectionModeMSFT" type="enum"> + <enum value="1" name="XR_REPROJECTION_MODE_DEPTH_MSFT"/> + <enum value="2" name="XR_REPROJECTION_MODE_PLANAR_FROM_DEPTH_MSFT"/> + <enum value="3" name="XR_REPROJECTION_MODE_PLANAR_MANUAL_MSFT"/> + <enum value="4" name="XR_REPROJECTION_MODE_ORIENTATION_ONLY_MSFT"/> + </enums> + + <!-- XR_BD_body_tracking --> + <enums name="XrBodyJointBD" type="enum"> + <enum value="0" name="XR_BODY_JOINT_PELVIS_BD"/> + <enum value="1" name="XR_BODY_JOINT_LEFT_HIP_BD"/> + <enum value="2" name="XR_BODY_JOINT_RIGHT_HIP_BD"/> + <enum value="3" name="XR_BODY_JOINT_SPINE1_BD"/> + <enum value="4" name="XR_BODY_JOINT_LEFT_KNEE_BD"/> + <enum value="5" name="XR_BODY_JOINT_RIGHT_KNEE_BD"/> + <enum value="6" name="XR_BODY_JOINT_SPINE2_BD"/> + <enum value="7" name="XR_BODY_JOINT_LEFT_ANKLE_BD"/> + <enum value="8" name="XR_BODY_JOINT_RIGHT_ANKLE_BD"/> + <enum value="9" name="XR_BODY_JOINT_SPINE3_BD"/> + <enum value="10" name="XR_BODY_JOINT_LEFT_FOOT_BD"/> + <enum value="11" name="XR_BODY_JOINT_RIGHT_FOOT_BD"/> + <enum value="12" name="XR_BODY_JOINT_NECK_BD"/> + <enum value="13" name="XR_BODY_JOINT_LEFT_COLLAR_BD"/> + <enum value="14" name="XR_BODY_JOINT_RIGHT_COLLAR_BD"/> + <enum value="15" name="XR_BODY_JOINT_HEAD_BD"/> + <enum value="16" name="XR_BODY_JOINT_LEFT_SHOULDER_BD"/> + <enum value="17" name="XR_BODY_JOINT_RIGHT_SHOULDER_BD"/> + <enum value="18" name="XR_BODY_JOINT_LEFT_ELBOW_BD"/> + <enum value="19" name="XR_BODY_JOINT_RIGHT_ELBOW_BD"/> + <enum value="20" name="XR_BODY_JOINT_LEFT_WRIST_BD"/> + <enum value="21" name="XR_BODY_JOINT_RIGHT_WRIST_BD"/> + <enum value="22" name="XR_BODY_JOINT_LEFT_HAND_BD"/> + <enum value="23" name="XR_BODY_JOINT_RIGHT_HAND_BD"/> + </enums> + + <enums name="XrBodyJointSetBD" type="enum" comment="Describes the set of body joints to track when creating an slink:XrBodyTrackerBD."> + <enum value="1" name="XR_BODY_JOINT_SET_BODY_WITHOUT_ARM_BD" comment="Contains joints in elink:XrBodyJointBD in the range ename:XR_BODY_JOINT_PELVIS_BD through ename:XR_BODY_JOINT_HEAD_BD inclusive, a total of dlink:XR_BODY_JOINT_WITHOUT_ARM_COUNT_BD joints."/> + <enum value="2" name="XR_BODY_JOINT_SET_FULL_BODY_JOINTS_BD" comment="Contains joints in elink:XrBodyJointBD in the range ename:XR_BODY_JOINT_PELVIS_BD through ename:XR_BODY_JOINT_RIGHT_HAND_BD inclusive, a total of dlink:XR_BODY_JOINT_COUNT_BD joints."/> + </enums> + + <!-- XR_BD_body_tracking_auxiliary_metrics --> + <enums name="XrBodyTrackingPostureBD" type="enum"> + <enum value="1" name="XR_BODY_TRACKING_POSTURE_STOMP_BD" comment="Represents a stomp posture."/> + <enum value="2" name="XR_BODY_TRACKING_POSTURE_STATIC_BD" comment="Represents a static posture where the tracked user maintains a fixed pose."/> + </enums> + + <enums name="XrBodyTrackingStatusBD" type="enum"> + <enum value="0" name="XR_BODY_TRACKING_STATUS_INVALID_BD" comment="Body tracking status is invalid"/> + <enum value="1" name="XR_BODY_TRACKING_STATUS_VALID_BD" comment="Body tracking status is valid"/> + <enum value="2" name="XR_BODY_TRACKING_STATUS_LIMITED_BD" comment="Body tracking status is limited"/> + </enums> + + <enums name="XrBodyTrackingMessageBD" type="enum"> + <enum value="0" name="XR_BODY_TRACKING_MESSAGE_NO_ERROR_BD" comment="No error"/> + <enum value="1" name="XR_BODY_TRACKING_MESSAGE_TRACKER_NOT_CALIBRATED_BD" comment="Body tracker is not calibrated"/> + <enum value="2" name="XR_BODY_TRACKING_MESSAGE_TRACKER_NUM_NOT_ENOUGH_BD" comment="The number of connected trackers is insufficient."/> + <enum value="3" name="XR_BODY_TRACKING_MESSAGE_TRACKER_STATE_NOT_SATISFIED_BD" comment="The tracker is not in normal tracking mode, e.g., it is being charged."/> + <enum value="4" name="XR_BODY_TRACKING_MESSAGE_TRACKER_PERSISTENT_INVISIBILITY_BD" comment="The tracker remains persistently undetected or invisible."/> + <enum value="5" name="XR_BODY_TRACKING_MESSAGE_TRACKER_DATA_ERROR_BD" comment="There are errors in the data generated by the tracker."/> + <enum value="6" name="XR_BODY_TRACKING_MESSAGE_USER_CHANGE_BD" comment="The user of the tracker may have been changed."/> + <enum value="7" name="XR_BODY_TRACKING_MESSAGE_TRACKING_POSE_ERROR_BD" comment="The body tracking pose is abnormal, e.g. the head is twisted."/> + </enums> + + <!-- XR_ULTRALEAP_hand_tracking_forearm --> + <enums name="XrHandForearmJointULTRALEAP" type="enum"> + <enum value="0" name="XR_HAND_FOREARM_JOINT_PALM_ULTRALEAP"/> + <enum value="1" name="XR_HAND_FOREARM_JOINT_WRIST_ULTRALEAP"/> + <enum value="2" name="XR_HAND_FOREARM_JOINT_THUMB_METACARPAL_ULTRALEAP"/> + <enum value="3" name="XR_HAND_FOREARM_JOINT_THUMB_PROXIMAL_ULTRALEAP"/> + <enum value="4" name="XR_HAND_FOREARM_JOINT_THUMB_DISTAL_ULTRALEAP"/> + <enum value="5" name="XR_HAND_FOREARM_JOINT_THUMB_TIP_ULTRALEAP"/> + <enum value="6" name="XR_HAND_FOREARM_JOINT_INDEX_METACARPAL_ULTRALEAP"/> + <enum value="7" name="XR_HAND_FOREARM_JOINT_INDEX_PROXIMAL_ULTRALEAP"/> + <enum value="8" name="XR_HAND_FOREARM_JOINT_INDEX_INTERMEDIATE_ULTRALEAP"/> + <enum value="9" name="XR_HAND_FOREARM_JOINT_INDEX_DISTAL_ULTRALEAP"/> + <enum value="10" name="XR_HAND_FOREARM_JOINT_INDEX_TIP_ULTRALEAP"/> + <enum value="11" name="XR_HAND_FOREARM_JOINT_MIDDLE_METACARPAL_ULTRALEAP"/> + <enum value="12" name="XR_HAND_FOREARM_JOINT_MIDDLE_PROXIMAL_ULTRALEAP"/> + <enum value="13" name="XR_HAND_FOREARM_JOINT_MIDDLE_INTERMEDIATE_ULTRALEAP"/> + <enum value="14" name="XR_HAND_FOREARM_JOINT_MIDDLE_DISTAL_ULTRALEAP"/> + <enum value="15" name="XR_HAND_FOREARM_JOINT_MIDDLE_TIP_ULTRALEAP"/> + <enum value="16" name="XR_HAND_FOREARM_JOINT_RING_METACARPAL_ULTRALEAP"/> + <enum value="17" name="XR_HAND_FOREARM_JOINT_RING_PROXIMAL_ULTRALEAP"/> + <enum value="18" name="XR_HAND_FOREARM_JOINT_RING_INTERMEDIATE_ULTRALEAP"/> + <enum value="19" name="XR_HAND_FOREARM_JOINT_RING_DISTAL_ULTRALEAP"/> + <enum value="20" name="XR_HAND_FOREARM_JOINT_RING_TIP_ULTRALEAP"/> + <enum value="21" name="XR_HAND_FOREARM_JOINT_LITTLE_METACARPAL_ULTRALEAP"/> + <enum value="22" name="XR_HAND_FOREARM_JOINT_LITTLE_PROXIMAL_ULTRALEAP"/> + <enum value="23" name="XR_HAND_FOREARM_JOINT_LITTLE_INTERMEDIATE_ULTRALEAP"/> + <enum value="24" name="XR_HAND_FOREARM_JOINT_LITTLE_DISTAL_ULTRALEAP"/> + <enum value="25" name="XR_HAND_FOREARM_JOINT_LITTLE_TIP_ULTRALEAP"/> + <enum value="26" name="XR_HAND_FOREARM_JOINT_ELBOW_ULTRALEAP"/> + </enums> + + <!-- enums for XR_ML_marker_understanding --> + <enums name="XrMarkerDetectorProfileML" type="enum"> + <enum value="0" name="XR_MARKER_DETECTOR_PROFILE_DEFAULT_ML" comment="Tracker profile that covers standard use cases. If this does not suite the needs of the application try the other profiles listed below."/> + <enum value="1" name="XR_MARKER_DETECTOR_PROFILE_SPEED_ML" comment="Optimized for speed. Use this profile to reduce the compute load and increase detection/tracker speed. This can result in low accuracy poses."/> + <enum value="2" name="XR_MARKER_DETECTOR_PROFILE_ACCURACY_ML" comment="Optimized for accuracy. Use this profile to optimize for accurate marker poses. This can cause increased load on the compute."/> + <enum value="3" name="XR_MARKER_DETECTOR_PROFILE_SMALL_TARGETS_ML" comment="Optimized for small targets. Use this profile to optimize for markers that are small or for larger markers that need to be detected from afar."/> + <enum value="4" name="XR_MARKER_DETECTOR_PROFILE_LARGE_FOV_ML" comment="Optimized for FoV. Use this profile to be able to detect markers across a larger FoV. The marker tracker system will attempt to use multiple cameras to detect the markers."/> + <enum value="5" name="XR_MARKER_DETECTOR_PROFILE_CUSTOM_ML" comment="Custom Tracker Profile. The application can define a custom tracker profile. See slink:XrMarkerDetectorCustomProfileInfoML for more details."/> + </enums> + <enums name="XrMarkerTypeML" type="enum"> + <enum value="0" name="XR_MARKER_TYPE_ARUCO_ML" comment="Aruco Marker detection and localization. The marker id of the Aruco marker is available via flink:xrGetMarkerNumberML."/> + <enum value="1" name="XR_MARKER_TYPE_APRIL_TAG_ML" comment="AprilTag detection and localization. The marker id of the AprilTags is available via flink:xrGetMarkerNumberML."/> + <enum value="2" name="XR_MARKER_TYPE_QR_ML" comment="QR code detection and localization. The contents of the QR code is available via flink:xrGetMarkerStringML."/> + <enum value="3" name="XR_MARKER_TYPE_EAN_13_ML" comment="EAN-13, detection only, not locatable. The contents of the barcode is available via flink:xrGetMarkerStringML."/> + <enum value="4" name="XR_MARKER_TYPE_UPC_A_ML" comment="UPC-A, detection only, not locatable. The contents of the barcode is available via flink:xrGetMarkerStringML."/> + <enum value="5" name="XR_MARKER_TYPE_CODE_128_ML" comment="Code 128, detection only, not locatable. The contents of the barcode is available via flink:xrGetMarkerStringML."/> + </enums> + <enums name="XrMarkerArucoDictML" type="enum"> + <enum value="0" name="XR_MARKER_ARUCO_DICT_4X4_50_ML" comment="4 by 4 pixel Aruco marker dictionary with 50 IDs."/> + <enum value="1" name="XR_MARKER_ARUCO_DICT_4X4_100_ML" comment="4 by 4 pixel Aruco marker dictionary with 100 IDs."/> + <enum value="2" name="XR_MARKER_ARUCO_DICT_4X4_250_ML" comment="4 by 4 pixel Aruco marker dictionary with 250 IDs."/> + <enum value="3" name="XR_MARKER_ARUCO_DICT_4X4_1000_ML" comment="4 by 4 pixel Aruco marker dictionary with 1000 IDs."/> + <enum value="4" name="XR_MARKER_ARUCO_DICT_5X5_50_ML" comment="5 by 5 pixel Aruco marker dictionary with 50 IDs."/> + <enum value="5" name="XR_MARKER_ARUCO_DICT_5X5_100_ML" comment="5 by 5 pixel Aruco marker dictionary with 100 IDs."/> + <enum value="6" name="XR_MARKER_ARUCO_DICT_5X5_250_ML" comment="5 by 5 pixel Aruco marker dictionary with 250 IDs."/> + <enum value="7" name="XR_MARKER_ARUCO_DICT_5X5_1000_ML" comment="5 by 5 pixel Aruco marker dictionary with 1000 IDs."/> + <enum value="8" name="XR_MARKER_ARUCO_DICT_6X6_50_ML" comment="6 by 6 pixel Aruco marker dictionary with 50 IDs."/> + <enum value="9" name="XR_MARKER_ARUCO_DICT_6X6_100_ML" comment="6 by 6 pixel Aruco marker dictionary with 100 IDs."/> + <enum value="10" name="XR_MARKER_ARUCO_DICT_6X6_250_ML" comment="6 by 6 pixel Aruco marker dictionary with 250 IDs."/> + <enum value="11" name="XR_MARKER_ARUCO_DICT_6X6_1000_ML" comment="6 by 6 pixel Aruco marker dictionary with 1000 IDs."/> + <enum value="12" name="XR_MARKER_ARUCO_DICT_7X7_50_ML" comment="7 by 7 pixel Aruco marker dictionary with 50 IDs."/> + <enum value="13" name="XR_MARKER_ARUCO_DICT_7X7_100_ML" comment="7 by 7 pixel Aruco marker dictionary with 100 IDs."/> + <enum value="14" name="XR_MARKER_ARUCO_DICT_7X7_250_ML" comment="7 by 7 pixel Aruco marker dictionary with 250 IDs."/> + <enum value="15" name="XR_MARKER_ARUCO_DICT_7X7_1000_ML" comment="7 by 7 pixel Aruco marker dictionary with 1000 IDs."/> + </enums> + <enums name="XrMarkerAprilTagDictML" type="enum"> + <enum value="0" name="XR_MARKER_APRIL_TAG_DICT_16H5_ML" comment="4 by 4 bits, minimum Hamming distance between any two codes = 5, 30 codes."/> + <enum value="1" name="XR_MARKER_APRIL_TAG_DICT_25H9_ML" comment="5 by 5 bits, minimum Hamming distance between any two codes = 9, 35 codes."/> + <enum value="2" name="XR_MARKER_APRIL_TAG_DICT_36H10_ML" comment="6 by 6 bits, minimum Hamming distance between any two codes = 10, 2320 codes."/> + <enum value="3" name="XR_MARKER_APRIL_TAG_DICT_36H11_ML" comment="6 by 6 bits, minimum Hamming distance between any two codes = 11, 587 codes."/> + </enums> + <enums name="XrMarkerDetectorFpsML" type="enum"> + <enum value="0" name="XR_MARKER_DETECTOR_FPS_LOW_ML" comment="Low FPS."/> + <enum value="1" name="XR_MARKER_DETECTOR_FPS_MEDIUM_ML" comment="Medium FPS."/> + <enum value="2" name="XR_MARKER_DETECTOR_FPS_HIGH_ML" comment="High FPS."/> + <enum value="3" name="XR_MARKER_DETECTOR_FPS_MAX_ML" comment="Max possible FPS."/> + </enums> + <enums name="XrMarkerDetectorResolutionML" type="enum"> + <enum value="0" name="XR_MARKER_DETECTOR_RESOLUTION_LOW_ML" comment="Low Resolution."/> + <enum value="1" name="XR_MARKER_DETECTOR_RESOLUTION_MEDIUM_ML" comment="Medium Resolution."/> + <enum value="2" name="XR_MARKER_DETECTOR_RESOLUTION_HIGH_ML" comment="High Resolution."/> + </enums> + <enums name="XrMarkerDetectorCameraML" type="enum"> + <enum value="0" name="XR_MARKER_DETECTOR_CAMERA_RGB_CAMERA_ML" comment="Single RGB camera."/> + <enum value="1" name="XR_MARKER_DETECTOR_CAMERA_WORLD_CAMERAS_ML" comment="One or more world cameras."/> + </enums> + <enums name="XrMarkerDetectorCornerRefineMethodML" type="enum"> + <enum value="0" name="XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_NONE_ML" comment="No refinement. Inaccurate corners."/> + <enum value="1" name="XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_SUBPIX_ML" comment="Subpixel refinement. Corners have subpixel coordinates. High detection rate, very fast, reasonable accuracy."/> + <enum value="2" name="XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_CONTOUR_ML" comment="Contour refinement. High detection rate, fast, reasonable accuracy."/> + <enum value="3" name="XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_APRIL_TAG_ML" comment="AprilTag refinement. Reasonable detection rate, slowest, but very accurate. Only valid with AprilTags."/> + </enums> + <enums name="XrMarkerDetectorFullAnalysisIntervalML" type="enum"> + <enum value="0" name="XR_MARKER_DETECTOR_FULL_ANALYSIS_INTERVAL_MAX_ML" comment="Detector analyzes every frame fully."/> + <enum value="1" name="XR_MARKER_DETECTOR_FULL_ANALYSIS_INTERVAL_FAST_ML" comment="Detector analyzes frame fully very often."/> + <enum value="2" name="XR_MARKER_DETECTOR_FULL_ANALYSIS_INTERVAL_MEDIUM_ML" comment="Detector analyzes frame fully a few times per second."/> + <enum value="3" name="XR_MARKER_DETECTOR_FULL_ANALYSIS_INTERVAL_SLOW_ML" comment="Detector analyzes frame fully about every second."/> + </enums> + <enums name="XrMarkerDetectorStatusML" type="enum"> + <enum value="0" name="XR_MARKER_DETECTOR_STATUS_PENDING_ML" comment="The marker detector is working on a new snapshot."/> + <enum value="1" name="XR_MARKER_DETECTOR_STATUS_READY_ML" comment="The marker detector is ready to be inspected."/> + <enum value="2" name="XR_MARKER_DETECTOR_STATUS_ERROR_ML" comment="The marker detector has encountered a fatal error."/> + </enums> + + <!-- XR_ANDROID_spatial_object_tracking --> + <enums name="XrSpatialObjectSemanticLabelANDROID" type="enum"> + <enum value="0" name="XR_SPATIAL_OBJECT_SEMANTIC_LABEL_UNCATEGORIZED_ANDROID" comment="The runtime was unable to classify this entity."/> + <enum value="1" name="XR_SPATIAL_OBJECT_SEMANTIC_LABEL_KEYBOARD_ANDROID" comment="The entity is a keyboard."/> + <enum value="2" name="XR_SPATIAL_OBJECT_SEMANTIC_LABEL_MOUSE_ANDROID" comment="The entity is a mouse."/> + <enum value="3" name="XR_SPATIAL_OBJECT_SEMANTIC_LABEL_LAPTOP_BASE_ANDROID" comment="The entity is a laptop."/> + </enums> + + <!-- Flags --> + <enums name="XrInstanceCreateFlagBits" type="bitmask"> + <!-- This is currently empty, awaiting future flags. --> + </enums> + <enums name="XrSessionCreateFlagBits" type="bitmask"> + <!-- This is currently empty, awaiting future flags. --> + </enums> + <enums name="XrSwapchainCreateFlagBits" type="bitmask"> + <enum bitpos="0" name="XR_SWAPCHAIN_CREATE_PROTECTED_CONTENT_BIT" comment="Content will be protected from CPU access"/> + <enum bitpos="1" name="XR_SWAPCHAIN_CREATE_STATIC_IMAGE_BIT" comment="Only one image will be acquired from this swapchain over its lifetime"/> + </enums> + <enums name="XrSwapchainUsageFlagBits" type="bitmask"> + <enum bitpos="0" name="XR_SWAPCHAIN_USAGE_COLOR_ATTACHMENT_BIT" comment="Specifies that the image may: be a color rendering target."/> + <enum bitpos="1" name="XR_SWAPCHAIN_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT" comment="Specifies that the image may: be a depth/stencil rendering target."/> + <enum bitpos="2" name="XR_SWAPCHAIN_USAGE_UNORDERED_ACCESS_BIT" comment="Specifies that the image may: be accessed out of order and that access may: be via atomic operations."/> + <enum bitpos="3" name="XR_SWAPCHAIN_USAGE_TRANSFER_SRC_BIT" comment="Specifies that the image may: be used as the source of a transfer operation."/> + <enum bitpos="4" name="XR_SWAPCHAIN_USAGE_TRANSFER_DST_BIT" comment="Specifies that the image may: be used as the destination of a transfer operation."/> + <enum bitpos="5" name="XR_SWAPCHAIN_USAGE_SAMPLED_BIT" comment="Specifies that the image may: be sampled by a shader."/> + <enum bitpos="6" name="XR_SWAPCHAIN_USAGE_MUTABLE_FORMAT_BIT" comment="Specifies that the image may: be reinterpreted as another image format."/> + </enums> + <enums name="XrViewStateFlagBits" type="bitmask"> + <enum bitpos="0" name="XR_VIEW_STATE_ORIENTATION_VALID_BIT" comment="Indicates validity of all slink:XrView orientations"/> + <enum bitpos="1" name="XR_VIEW_STATE_POSITION_VALID_BIT" comment="Indicates validity of all slink:XrView positions"/> + <enum bitpos="2" name="XR_VIEW_STATE_ORIENTATION_TRACKED_BIT" comment="Indicates whether all slink:XrView orientations are actively tracked"/> + <enum bitpos="3" name="XR_VIEW_STATE_POSITION_TRACKED_BIT" comment="Indicates whether all slink:XrView positions are actively tracked"/> + </enums> + <enums name="XrCompositionLayerFlagBits" type="bitmask"> + <enum bitpos="0" name="XR_COMPOSITION_LAYER_CORRECT_CHROMATIC_ABERRATION_BIT" comment="Enables chromatic aberration correction when not done by default. This flag has no effect on any known conformant runtime, and is officially deprecated in OpenXR 1.1." deprecated="ignored"/> + <enum bitpos="1" name="XR_COMPOSITION_LAYER_BLEND_TEXTURE_SOURCE_ALPHA_BIT" comment="Enables the layer texture alpha channel."/> + <enum bitpos="2" name="XR_COMPOSITION_LAYER_UNPREMULTIPLIED_ALPHA_BIT" comment="Indicates the texture color channels have not been premultiplied by the texture alpha channel."/> + </enums> + + <enums name="XrSpaceLocationFlagBits" type="bitmask"> + <enum bitpos="0" name="XR_SPACE_LOCATION_ORIENTATION_VALID_BIT" comment="Indicates that the pname:orientation member contains valid data"/> + <enum bitpos="1" name="XR_SPACE_LOCATION_POSITION_VALID_BIT" comment="Indicates that the pname:position member contains valid data"/> + <enum bitpos="2" name="XR_SPACE_LOCATION_ORIENTATION_TRACKED_BIT" comment="Indicates whether pname:pose member contains an actively tracked pname:orientation"/> + <enum bitpos="3" name="XR_SPACE_LOCATION_POSITION_TRACKED_BIT" comment="Indicates whether pname:pose member contains an actively tracked pname:position"/> + </enums> + <enums name="XrSpaceVelocityFlagBits" type="bitmask"> + <enum bitpos="0" name="XR_SPACE_VELOCITY_LINEAR_VALID_BIT" comment="Indicates that the pname:linearVelocity member contains valid data. Applications must: not read the pname:linearVelocity field if this flag is unset."/> + <enum bitpos="1" name="XR_SPACE_VELOCITY_ANGULAR_VALID_BIT" comment="Indicates that the pname:angularVelocity member contains valid data. Applications must: not read the pname:angularVelocity field if this flag is unset."/> + </enums> + + <enums name="XrInputSourceLocalizedNameFlagBits" type="bitmask"> + <enum bitpos="0" name="XR_INPUT_SOURCE_LOCALIZED_NAME_USER_PATH_BIT" comment="Asks for the part of the string which indicates the top level user path the source represents"/> + <enum bitpos="1" name="XR_INPUT_SOURCE_LOCALIZED_NAME_INTERACTION_PROFILE_BIT" comment="Asks for the part of the string which represents the interaction profile of the source"/> + <enum bitpos="2" name="XR_INPUT_SOURCE_LOCALIZED_NAME_COMPONENT_BIT" comment="Asks for the part of the string which represents the component on the device which needs to be interacted with"/> + </enums> + + <!-- openxr_loader_negotiation.h --> + <enums name="XrLoaderInterfaceStructs" type="enum"> + <enum value="0" name="XR_LOADER_INTERFACE_STRUCT_UNINTIALIZED"/> + <enum value="1" name="XR_LOADER_INTERFACE_STRUCT_LOADER_INFO"/> + <enum value="2" name="XR_LOADER_INTERFACE_STRUCT_API_LAYER_REQUEST"/> + <enum value="3" name="XR_LOADER_INTERFACE_STRUCT_RUNTIME_REQUEST"/> + <enum value="4" name="XR_LOADER_INTERFACE_STRUCT_API_LAYER_CREATE_INFO"/> + <enum value="5" name="XR_LOADER_INTERFACE_STRUCT_API_LAYER_NEXT_INFO"/> + </enums> + + <!-- flags for XR_KHR_vulkan_enable2 --> + <enums name="XrVulkanInstanceCreateFlagBitsKHR" type="bitmask"> + <!-- This is currently empty, awaiting future flags. --> + </enums> + <enums name="XrVulkanDeviceCreateFlagBitsKHR" type="bitmask"> + <!-- This is currently empty, awaiting future flags. --> + </enums> + + <!-- flags for XR_EXT_debug_utils --> + <enums name="XrDebugUtilsMessageSeverityFlagBitsEXT" type="bitmask"> + <enum bitpos="0" name="XR_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT" comment="Most verbose output severity, typically used for debugging."/> + <enum bitpos="4" name="XR_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT" comment="General info message"/> + <enum bitpos="8" name="XR_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT" comment="Indicates the item may be the cause of issues."/> + <enum bitpos="12" name="XR_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT" comment="Indicates that the item is definitely related to erroneous behavior."/> + </enums> + <enums name="XrDebugUtilsMessageTypeFlagBitsEXT" type="bitmask"> + <enum bitpos="0" name="XR_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT" comment="Indicates this is a general message"/> + <enum bitpos="1" name="XR_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT" comment="Indicates the message is related to a validation message"/> + <enum bitpos="2" name="XR_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT" comment="Indicates the message is related to a potential performance situation"/> + <enum bitpos="3" name="XR_DEBUG_UTILS_MESSAGE_TYPE_CONFORMANCE_BIT_EXT" comment="Indicates the message is related to a non-conformant runtime result"/> + </enums> + + <!-- flags for XR_EXTX_overlay --> + <enums name="XrOverlayMainSessionFlagBitsEXTX" type="bitmask"> + <enum bitpos="0" name="XR_OVERLAY_MAIN_SESSION_ENABLED_COMPOSITION_LAYER_INFO_DEPTH_BIT_EXTX" comment="Indicates the main session enabled `XR_KHR_composition_layer_depth`"/> + </enums> + <enums name="XrOverlaySessionCreateFlagBitsEXTX" type="bitmask"> + </enums> + + <!-- enums XR_MSFT_spatial_graph_bridge --> + <enums name="XrSpatialGraphNodeTypeMSFT" type="enum"> + <enum value="1" name="XR_SPATIAL_GRAPH_NODE_TYPE_STATIC_MSFT"/> + <enum value="2" name="XR_SPATIAL_GRAPH_NODE_TYPE_DYNAMIC_MSFT"/> + </enums> + + <!-- enums XR_MSFT_scene_understanding --> + <enums name="XrSceneObjectTypeMSFT" type="enum"> + <enum value="-1" name="XR_SCENE_OBJECT_TYPE_UNCATEGORIZED_MSFT"/> + <enum value="1" name="XR_SCENE_OBJECT_TYPE_BACKGROUND_MSFT"/> + <enum value="2" name="XR_SCENE_OBJECT_TYPE_WALL_MSFT"/> + <enum value="3" name="XR_SCENE_OBJECT_TYPE_FLOOR_MSFT"/> + <enum value="4" name="XR_SCENE_OBJECT_TYPE_CEILING_MSFT"/> + <enum value="5" name="XR_SCENE_OBJECT_TYPE_PLATFORM_MSFT"/> + <enum value="6" name="XR_SCENE_OBJECT_TYPE_INFERRED_MSFT"/> + </enums> + <enums name="XrScenePlaneAlignmentTypeMSFT" type="enum"> + <enum value="0" name="XR_SCENE_PLANE_ALIGNMENT_TYPE_NON_ORTHOGONAL_MSFT"/> + <enum value="1" name="XR_SCENE_PLANE_ALIGNMENT_TYPE_HORIZONTAL_MSFT"/> + <enum value="2" name="XR_SCENE_PLANE_ALIGNMENT_TYPE_VERTICAL_MSFT"/> + </enums> + <enums name="XrSceneComputeStateMSFT" type="enum"> + <enum value="0" name="XR_SCENE_COMPUTE_STATE_NONE_MSFT"/> + <enum value="1" name="XR_SCENE_COMPUTE_STATE_UPDATING_MSFT"/> + <enum value="2" name="XR_SCENE_COMPUTE_STATE_COMPLETED_MSFT"/> + <enum value="3" name="XR_SCENE_COMPUTE_STATE_COMPLETED_WITH_ERROR_MSFT"/> + </enums> + <enums name="XrSceneComponentTypeMSFT" type="enum"> + <enum value="-1" name="XR_SCENE_COMPONENT_TYPE_INVALID_MSFT"/> + <enum value="1" name="XR_SCENE_COMPONENT_TYPE_OBJECT_MSFT"/> + <enum value="2" name="XR_SCENE_COMPONENT_TYPE_PLANE_MSFT"/> + <enum value="3" name="XR_SCENE_COMPONENT_TYPE_VISUAL_MESH_MSFT"/> + <enum value="4" name="XR_SCENE_COMPONENT_TYPE_COLLIDER_MESH_MSFT"/> + </enums> + <enums name="XrSceneComputeFeatureMSFT" type="enum"> + <enum value="1" name="XR_SCENE_COMPUTE_FEATURE_PLANE_MSFT"/> + <enum value="2" name="XR_SCENE_COMPUTE_FEATURE_PLANE_MESH_MSFT"/> + <enum value="3" name="XR_SCENE_COMPUTE_FEATURE_VISUAL_MESH_MSFT"/> + <enum value="4" name="XR_SCENE_COMPUTE_FEATURE_COLLIDER_MESH_MSFT"/> + </enums> + <enums name="XrSceneComputeConsistencyMSFT" type="enum"> + <enum value="1" name="XR_SCENE_COMPUTE_CONSISTENCY_SNAPSHOT_COMPLETE_MSFT"/> + <enum value="2" name="XR_SCENE_COMPUTE_CONSISTENCY_SNAPSHOT_INCOMPLETE_FAST_MSFT"/> + <enum value="3" name="XR_SCENE_COMPUTE_CONSISTENCY_OCCLUSION_OPTIMIZED_MSFT"/> + </enums> + <enums name="XrMeshComputeLodMSFT" type="enum"> + <enum value="1" name="XR_MESH_COMPUTE_LOD_COARSE_MSFT"/> + <enum value="2" name="XR_MESH_COMPUTE_LOD_MEDIUM_MSFT"/> + <enum value="3" name="XR_MESH_COMPUTE_LOD_FINE_MSFT"/> + <enum value="4" name="XR_MESH_COMPUTE_LOD_UNLIMITED_MSFT"/> + </enums> + + <!-- enums for XR_MSFT_scene_marker --> + <enums name="XrSceneMarkerTypeMSFT" type="enum"> + <enum value="1" name="XR_SCENE_MARKER_TYPE_QR_CODE_MSFT"/> + </enums> + <enums name="XrSceneMarkerQRCodeSymbolTypeMSFT" type="enum"> + <enum value="1" name="XR_SCENE_MARKER_QR_CODE_SYMBOL_TYPE_QR_CODE_MSFT"/> + <enum value="2" name="XR_SCENE_MARKER_QR_CODE_SYMBOL_TYPE_MICRO_QR_CODE_MSFT"/> + </enums> + + <!-- flags for XR_FB_android_surface_swapchain_create --> + <enums name="XrAndroidSurfaceSwapchainFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_ANDROID_SURFACE_SWAPCHAIN_SYNCHRONOUS_BIT_FB" comment="Create the underlying BufferQueue in synchronous mode"/> + <enum bitpos="1" name="XR_ANDROID_SURFACE_SWAPCHAIN_USE_TIMESTAMPS_BIT_FB" comment="Acquire most recent buffer whose presentation timestamp is not greater than display time of final composited frame"/> + </enums> + + <!-- flags for XR_FB_composition_layer_image_layout --> + <enums name="XrCompositionLayerImageLayoutFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_COMPOSITION_LAYER_IMAGE_LAYOUT_VERTICAL_FLIP_BIT_FB" comment="The coordinate origin of the swapchain image must be considered to be flipped vertically."/> + </enums> + + <!-- flags for XR_FB_foveation --> + <enums name="XrSwapchainCreateFoveationFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_SWAPCHAIN_CREATE_FOVEATION_SCALED_BIN_BIT_FB" comment="Explicitly create the swapchain with scaled bin foveation support. The application must ensure that the swapchain is using the OpenGL graphics API and that the QCOM_texture_foveated extension is supported and enabled."/> + <enum bitpos="1" name="XR_SWAPCHAIN_CREATE_FOVEATION_FRAGMENT_DENSITY_MAP_BIT_FB" comment="Explicitly create the swapchain with fragment density map foveation support. The application must ensure that the swapchain is using the Vulkan graphics API and that the VK_EXT_fragment_density_map extension is supported and enabled."/> + </enums> + <enums name="XrSwapchainStateFoveationFlagBitsFB" type="bitmask"> + <!-- This is currently empty, awaiting future flags. --> + </enums> + + <!-- flags for XR_META_foveation_eye_tracked --> + <enums name="XrFoveationEyeTrackedProfileCreateFlagBitsMETA" type="bitmask"> + <!-- This is currently empty, awaiting future flags. --> + </enums> + <enums name="XrFoveationEyeTrackedStateFlagBitsMETA" type="bitmask"> + <enum bitpos="0" name="XR_FOVEATION_EYE_TRACKED_STATE_VALID_BIT_META" comment="Indicates whether or not foveation data is valid. This can happen if the eye tracker is obscured, the camera has dirt, or eye lid is closed, etc."/> + </enums> + + <!-- flags for XR_FB_composition_layer_secure_content --> + <enums name="XrCompositionLayerSecureContentFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_COMPOSITION_LAYER_SECURE_CONTENT_EXCLUDE_LAYER_BIT_FB" comment="Indicates the layer will only be visible inside the HMD, and not visible to external sources"/> + <enum bitpos="1" name="XR_COMPOSITION_LAYER_SECURE_CONTENT_REPLACE_LAYER_BIT_FB" comment="Indicates the layer will be displayed inside the HMD, but replaced by proxy content when written to external sources"/> + </enums> + + <!-- enums for XR_FB_spatial_entity --> + <enums name="XrSpaceComponentTypeFB" type="enum"> + <enum value="0" name="XR_SPACE_COMPONENT_TYPE_LOCATABLE_FB" comment="Enables tracking the 6 DOF pose of the slink:XrSpace with flink:xrLocateSpace."/> + <enum value="1" name="XR_SPACE_COMPONENT_TYPE_STORABLE_FB" comment="Enables persistence operations: save and erase."/> + <enum value="2" name="XR_SPACE_COMPONENT_TYPE_SHARABLE_FB" comment="Enables sharing of spatial entities."/> + <enum value="3" name="XR_SPACE_COMPONENT_TYPE_BOUNDED_2D_FB" comment="Bounded 2D component."/> + <enum value="4" name="XR_SPACE_COMPONENT_TYPE_BOUNDED_3D_FB" comment="Bounded 3D component."/> + <enum value="5" name="XR_SPACE_COMPONENT_TYPE_SEMANTIC_LABELS_FB" comment="Semantic labels component."/> + <enum value="6" name="XR_SPACE_COMPONENT_TYPE_ROOM_LAYOUT_FB" comment="Room layout component."/> + <enum value="7" name="XR_SPACE_COMPONENT_TYPE_SPACE_CONTAINER_FB" comment="Space container component."/> + </enums> + + <!-- enums for XR_FB_foveation_configuration --> + <enums name="XrFoveationLevelFB" type="enum"> + <enum value="0" name="XR_FOVEATION_LEVEL_NONE_FB" comment="No foveation"/> + <enum value="1" name="XR_FOVEATION_LEVEL_LOW_FB" comment="Less foveation (higher periphery visual fidelity, lower performance)"/> + <enum value="2" name="XR_FOVEATION_LEVEL_MEDIUM_FB" comment="Medium foveation (medium periphery visual fidelity, medium performance)"/> + <enum value="3" name="XR_FOVEATION_LEVEL_HIGH_FB" comment="High foveation (lower periphery visual fidelity, higher performance)"/> + </enums> + <enums name="XrFoveationDynamicFB" type="enum"> + <enum value="0" name="XR_FOVEATION_DYNAMIC_DISABLED_FB" comment="Static foveation at the maximum desired level"/> + <enum value="1" name="XR_FOVEATION_DYNAMIC_LEVEL_ENABLED_FB" comment="Dynamic changing foveation based on performance headroom available up to the maximum desired level"/> + </enums> + + <!-- enums for XR_FB_triangle_mesh --> + <enums name="XrWindingOrderFB" type="enum"> + <enum value="0" name="XR_WINDING_ORDER_UNKNOWN_FB" comment="Winding order is unknown and the runtime cannot make any assumptions on the triangle orientation"/> + <enum value="1" name="XR_WINDING_ORDER_CW_FB" comment="Clockwise winding order"/> + <enum value="2" name="XR_WINDING_ORDER_CCW_FB" comment="Counter-clockwise winding order"/> + </enums> + <enums name="XrTriangleMeshFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_TRIANGLE_MESH_MUTABLE_BIT_FB" comment="The triangle mesh is mutable (can be modified after it is created)."/> + </enums> + + <!-- enums for XR_FB_passthrough --> + <enums name="XrPassthroughLayerPurposeFB" type="enum"> + <enum value="0" name="XR_PASSTHROUGH_LAYER_PURPOSE_RECONSTRUCTION_FB" comment="Reconstruction passthrough (full screen environment)"/> + <enum value="1" name="XR_PASSTHROUGH_LAYER_PURPOSE_PROJECTED_FB" comment="Projected passthrough (using a custom surface)"/> + </enums> + <enums name="XrPassthroughFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_PASSTHROUGH_IS_RUNNING_AT_CREATION_BIT_FB" comment="The object (passthrough, layer) is running at creation."/> + <enum bitpos="1" name="XR_PASSTHROUGH_LAYER_DEPTH_BIT_FB" comment="The passthrough system sends depth information to the compositor. Only applicable to layer objects."/> + </enums> + <enums name="XrPassthroughStateChangedFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_PASSTHROUGH_STATE_CHANGED_REINIT_REQUIRED_BIT_FB" comment="Passthrough system requires reinitialization."/> + <enum bitpos="1" name="XR_PASSTHROUGH_STATE_CHANGED_NON_RECOVERABLE_ERROR_BIT_FB" comment="Non-recoverable error has occurred. A device reboot or a firmware update may be required."/> + <enum bitpos="2" name="XR_PASSTHROUGH_STATE_CHANGED_RECOVERABLE_ERROR_BIT_FB" comment="A recoverable error has occurred. The runtime will attempt to recover, but some functionality may be temporarily unavailable."/> + <enum bitpos="3" name="XR_PASSTHROUGH_STATE_CHANGED_RESTORED_ERROR_BIT_FB" comment="The runtime has recovered from a previous error and is functioning normally."/> + </enums> + <enums name="XrPassthroughCapabilityFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_PASSTHROUGH_CAPABILITY_BIT_FB" comment="The system supports passthrough."/> + <enum bitpos="1" name="XR_PASSTHROUGH_CAPABILITY_COLOR_BIT_FB" comment="The system can show passthrough with realistic colors. ename:XR_PASSTHROUGH_CAPABILITY_BIT_FB must: be set if ename:XR_PASSTHROUGH_CAPABILITY_COLOR_BIT_FB is set."/> + <enum bitpos="2" name="XR_PASSTHROUGH_CAPABILITY_LAYER_DEPTH_BIT_FB" comment="The system supports passthrough layers composited using depth testing. ename:XR_PASSTHROUGH_CAPABILITY_BIT_FB must: be set if ename:XR_PASSTHROUGH_CAPABILITY_LAYER_DEPTH_BIT_FB is set."/> + </enums> + + <!-- enums for XR_FB_spatial_entity_query --> + <enums name="XrSpaceQueryActionFB" type="enum"> + <enum value="0" name="XR_SPACE_QUERY_ACTION_LOAD_FB" comment="Tells the query to perform a load operation on any slink:XrSpace returned by the query."/> + </enums> + + <!-- enums for XR_FB_spatial_entity_storage --> + <enums name="XrSpaceStorageLocationFB" type="enum"> + <enum value="0" name="XR_SPACE_STORAGE_LOCATION_INVALID_FB" comment="Invalid storage location"/> + <enum value="1" name="XR_SPACE_STORAGE_LOCATION_LOCAL_FB" comment="Local device storage"/> + <enum value="2" name="XR_SPACE_STORAGE_LOCATION_CLOUD_FB" comment="Cloud storage"/> + </enums> + <enums name="XrSpacePersistenceModeFB" type="enum"> + <enum value="0" name="XR_SPACE_PERSISTENCE_MODE_INVALID_FB" comment="Invalid storage persistence"/> + <enum value="1" name="XR_SPACE_PERSISTENCE_MODE_INDEFINITE_FB" comment="Store slink:XrSpace indefinitely, or until erased"/> + </enums> + + <!-- enums for XR_META_spatial_entity_semantic_label --> + <enums name="XrSemanticLabelMETA" type="enum"> + <enum value="0" name="XR_SEMANTIC_LABEL_UNKNOWN_META" comment="Unknown. This is a valid label that is used when the runtime is not able to classify the entity using another label, or when the application does not recognize the label."/> + <enum value="1" name="XR_SEMANTIC_LABEL_FLOOR_META" comment="Floor of a room or space."/> + <enum value="2" name="XR_SEMANTIC_LABEL_CEILING_META" comment="Ceiling of a room or space."/> + <enum value="3" name="XR_SEMANTIC_LABEL_WALL_FACE_META" comment="Wall face of a room or space. Wall faces, along with invisible wall faces, are used to define the outer boundary of a room."/> + <enum value="4" name="XR_SEMANTIC_LABEL_INNER_WALL_FACE_META" comment="Inner wall face, which is a wall face that exists inside a room and is not connected to the outer boundary of the room. For example, a pillar that exists at the center of a room may: be represented by using four inner wall faces."/> + <enum value="5" name="XR_SEMANTIC_LABEL_INVISIBLE_WALL_FACE_META" comment="Invisible wall face, which is used to conceptually separate a space (e.g., separate a living space from a kitchen space in an open floor plan house even though there is no real wall between the two spaces)."/> + <enum value="6" name="XR_SEMANTIC_LABEL_DOOR_FRAME_META" comment="Door frame, which usually exists on a wall face."/> + <enum value="7" name="XR_SEMANTIC_LABEL_WINDOW_FRAME_META" comment="Window frame, which usually exists on a wall face."/> + </enums> + + <!-- enums for XR_META_boundary_visibility --> + <enums name="XrBoundaryVisibilityMETA" type="enum"> + <enum value="1" name="XR_BOUNDARY_VISIBILITY_NOT_SUPPRESSED_META" comment="Boundary visibility is not suppressed."/> + <enum value="2" name="XR_BOUNDARY_VISIBILITY_SUPPRESSED_META" comment="Boundary visibility is suppressed."/> + </enums> + + <!-- flags for XR_FB_scene --> + <enums name="XrSemanticLabelsSupportFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_SEMANTIC_LABELS_SUPPORT_MULTIPLE_SEMANTIC_LABELS_BIT_FB" comment="If set, and the runtime reports the pname:extensionVersion as 2 or greater, the runtime may: return multiple semantic labels separated by a comma without spaces. Otherwise, the runtime must: return a single semantic label."/> + <enum bitpos="1" name="XR_SEMANTIC_LABELS_SUPPORT_ACCEPT_DESK_TO_TABLE_MIGRATION_BIT_FB" comment="If set, and the runtime reports the pname:extensionVersion as 3 or greater, the runtime must: return "TABLE" instead of "DESK" as a semantic label to the application. Otherwise, the runtime must: return "DESK" instead of "TABLE" as a semantic label to the application, when applicable."/> + <enum bitpos="2" name="XR_SEMANTIC_LABELS_SUPPORT_ACCEPT_INVISIBLE_WALL_FACE_BIT_FB" comment="If set, and the runtime reports the pname:extensionVersion as 4 or greater, the runtime may: return "INVISIBLE_WALL_FACE" instead of "WALL_FACE" as a semantic label to the application in order to represent an invisible wall used to conceptually separate a space (e.g., separate a living space from a kitchen space in an open floor plan house even though there is no real wall between the two spaces) instead of a real wall. Otherwise, the runtime must: return "WALL_FACE" as a semantic label to the application in order to represent both an invisible and real wall, when applicable."/> + </enums> + + <!-- enums for XR_META_local_dimming --> + <enums name="XrLocalDimmingModeMETA" type="enum"> + <enum value="0" name="XR_LOCAL_DIMMING_MODE_OFF_META" comment="Local dimming is turned off by default for the current submitted frame. This is the same as not chaining elink:XrLocalDimmingModeMETA."/> + <enum value="1" name="XR_LOCAL_DIMMING_MODE_ON_META" comment="Local dimming is turned on for the current submitted frame."/> + </enums> + + <!-- flags for XR_FB_hand_tracking_aim --> + <enums name="XrHandTrackingAimFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_HAND_TRACKING_AIM_COMPUTED_BIT_FB" comment="Aiming data is computed from additional sources beyond the hand data in the base structure"/> + <enum bitpos="1" name="XR_HAND_TRACKING_AIM_VALID_BIT_FB" comment="Aiming data is valid"/> + <enum bitpos="2" name="XR_HAND_TRACKING_AIM_INDEX_PINCHING_BIT_FB" comment="Index finger pinch discrete signal"/> + <enum bitpos="3" name="XR_HAND_TRACKING_AIM_MIDDLE_PINCHING_BIT_FB" comment="Middle finger pinch discrete signal"/> + <enum bitpos="4" name="XR_HAND_TRACKING_AIM_RING_PINCHING_BIT_FB" comment="Ring finger pinch discrete signal"/> + <enum bitpos="5" name="XR_HAND_TRACKING_AIM_LITTLE_PINCHING_BIT_FB" comment="Little finger pinch discrete signal"/> + <enum bitpos="6" name="XR_HAND_TRACKING_AIM_SYSTEM_GESTURE_BIT_FB" comment="System gesture is active"/> + <enum bitpos="7" name="XR_HAND_TRACKING_AIM_DOMINANT_HAND_BIT_FB" comment="Hand is currently marked as dominant for the system"/> + <enum bitpos="8" name="XR_HAND_TRACKING_AIM_MENU_PRESSED_BIT_FB" comment="System menu gesture is active"/> + </enums> + + <!-- flags for XR_BD_body_tracking_auxiliary_metrics --> + <enums name="XrSpaceAccelerationFlagBitsBD" type="bitmask"> + <enum bitpos="0" name="XR_SPACE_ACCELERATION_LINEAR_VALID_BIT_BD" comment="Linear acceleration."/> + <enum bitpos="1" name="XR_SPACE_ACCELERATION_ANGULAR_VALID_BIT_BD" comment="Angular acceleration."/> + </enums> + + <!-- flags for XR_FB_keyboard_tracking query state --> + <enums name="XrKeyboardTrackingFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_KEYBOARD_TRACKING_EXISTS_BIT_FB" comment="indicates that the system has a physically tracked keyboard to report. If not set then no other bits should be considered to be valid or meaningful. If set either XR_KEYBOARD_TRACKING_LOCAL_BIT_FB or XR_KEYBOARD_TRACKING_REMOTE_BIT_FB must also be set."/> + <enum bitpos="1" name="XR_KEYBOARD_TRACKING_LOCAL_BIT_FB" comment="indicates that the physically tracked keyboard is intended to be used in a local pairing with the system. Mutually exclusive with XR_KEYBOARD_TRACKING_REMOTE_BIT_FB."/> + <enum bitpos="2" name="XR_KEYBOARD_TRACKING_REMOTE_BIT_FB" comment="indicates that the physically tracked keyboard is intended to be used while paired to a separate remote computing device. Mutually exclusive with XR_KEYBOARD_TRACKING_LOCAL_BIT_FB."/> + <enum bitpos="3" name="XR_KEYBOARD_TRACKING_CONNECTED_BIT_FB" comment="indicates that the physically tracked keyboard is actively connected to the headset and capable of sending key data"/> + </enums> + + <!-- flags for XR_FB_keyboard_tracking query --> + <enums name="XrKeyboardTrackingQueryFlagBitsFB" type="bitmask"> + <enum bitpos="1" name="XR_KEYBOARD_TRACKING_QUERY_LOCAL_BIT_FB" comment="indicates the query is for the physically tracked keyboard that is intended to be used in a local pairing with the System. Mutually exclusive with XR_KEYBOARD_TRACKING_QUERY_REMOTE_BIT_FB."/> + <enum bitpos="2" name="XR_KEYBOARD_TRACKING_QUERY_REMOTE_BIT_FB" comment="indicates the query is for the physically tracked keyboard that may be connected to a separate remote computing device. Mutually exclusive with XR_KEYBOARD_TRACKING_QUERY_LOCAL_BIT_FB."/> + </enums> + + <!-- flags for XR_FB_space_warp --> + <enums name="XrCompositionLayerSpaceWarpInfoFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_COMPOSITION_LAYER_SPACE_WARP_INFO_FRAME_SKIP_BIT_FB" comment="Skip current frame's space warp extrapolation"/> + </enums> + + <!-- flags for XR_FB_render_model --> + <enums name="XrRenderModelFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_RENDER_MODEL_SUPPORTS_GLTF_2_0_SUBSET_1_BIT_FB" comment="Minimal level of support. Can only contain a single mesh. Can only contain a single texture. Can not contain transparency. Assumes unlit rendering. Requires Extension KHR_texturebasisu."/> + <enum bitpos="1" name="XR_RENDER_MODEL_SUPPORTS_GLTF_2_0_SUBSET_2_BIT_FB" comment="All of XR_RENDER_MODEL_SUPPORTS_GLTF_2_0_SUBSET_1_BIT_FB support plus: Multiple meshes. Multiple Textures. Texture Transparency."/> + </enums> + + <!-- enums for XR_HTC_facial_tracking --> + <enums name="XrFacialTrackingTypeHTC" type="enum"> + <enum value="1" name="XR_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC" comment="Specifies this handle will observe eye expressions, with values indexed by elink:XrEyeExpressionHTC whose count is dlink:XR_FACIAL_EXPRESSION_EYE_COUNT_HTC."/> + <enum value="2" name="XR_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC" comment="Specifies this handle will observe lip expressions, with values indexed by elink:XrLipExpressionHTC whose count is dlink:XR_FACIAL_EXPRESSION_LIP_COUNT_HTC."/> + </enums> + + <!-- enums for XR_HTC_passthrough --> + <enums name="XrPassthroughFormHTC" type="enum"> + <enum value="0" name="XR_PASSTHROUGH_FORM_PLANAR_HTC" comment="Presents the passthrough with full of the entire screen."/> + <enum value="1" name="XR_PASSTHROUGH_FORM_PROJECTED_HTC" comment="Presents the passthrough projecting onto a custom mesh."/> + </enums> + + <enums name="XrEyeExpressionHTC" type="enum"> + <enum value="0" name="XR_EYE_EXPRESSION_LEFT_BLINK_HTC"/> + <enum value="1" name="XR_EYE_EXPRESSION_LEFT_WIDE_HTC"/> + <enum value="2" name="XR_EYE_EXPRESSION_RIGHT_BLINK_HTC"/> + <enum value="3" name="XR_EYE_EXPRESSION_RIGHT_WIDE_HTC"/> + <enum value="4" name="XR_EYE_EXPRESSION_LEFT_SQUEEZE_HTC"/> + <enum value="5" name="XR_EYE_EXPRESSION_RIGHT_SQUEEZE_HTC"/> + <enum value="6" name="XR_EYE_EXPRESSION_LEFT_DOWN_HTC"/> + <enum value="7" name="XR_EYE_EXPRESSION_RIGHT_DOWN_HTC"/> + <enum value="8" name="XR_EYE_EXPRESSION_LEFT_OUT_HTC"/> + <enum value="9" name="XR_EYE_EXPRESSION_RIGHT_IN_HTC"/> + <enum value="10" name="XR_EYE_EXPRESSION_LEFT_IN_HTC"/> + <enum value="11" name="XR_EYE_EXPRESSION_RIGHT_OUT_HTC"/> + <enum value="12" name="XR_EYE_EXPRESSION_LEFT_UP_HTC"/> + <enum value="13" name="XR_EYE_EXPRESSION_RIGHT_UP_HTC"/> + </enums> + + <enums name="XrLipExpressionHTC" type="enum"> + <enum value="0" name="XR_LIP_EXPRESSION_JAW_RIGHT_HTC"/> + <enum value="1" name="XR_LIP_EXPRESSION_JAW_LEFT_HTC"/> + <enum value="2" name="XR_LIP_EXPRESSION_JAW_FORWARD_HTC"/> + <enum value="3" name="XR_LIP_EXPRESSION_JAW_OPEN_HTC"/> + <enum value="4" name="XR_LIP_EXPRESSION_MOUTH_APE_SHAPE_HTC"/> + <enum value="5" name="XR_LIP_EXPRESSION_MOUTH_UPPER_RIGHT_HTC"/> + <enum value="6" name="XR_LIP_EXPRESSION_MOUTH_UPPER_LEFT_HTC"/> + <enum value="7" name="XR_LIP_EXPRESSION_MOUTH_LOWER_RIGHT_HTC"/> + <enum value="8" name="XR_LIP_EXPRESSION_MOUTH_LOWER_LEFT_HTC"/> + <enum value="9" name="XR_LIP_EXPRESSION_MOUTH_UPPER_OVERTURN_HTC"/> + <enum value="10" name="XR_LIP_EXPRESSION_MOUTH_LOWER_OVERTURN_HTC"/> + <enum value="11" name="XR_LIP_EXPRESSION_MOUTH_POUT_HTC"/> + <enum value="12" name="XR_LIP_EXPRESSION_MOUTH_RAISER_RIGHT_HTC"/> + <enum value="13" name="XR_LIP_EXPRESSION_MOUTH_RAISER_LEFT_HTC"/> + <enum value="14" name="XR_LIP_EXPRESSION_MOUTH_STRETCHER_RIGHT_HTC"/> + <enum value="15" name="XR_LIP_EXPRESSION_MOUTH_STRETCHER_LEFT_HTC"/> + <enum value="16" name="XR_LIP_EXPRESSION_CHEEK_PUFF_RIGHT_HTC"/> + <enum value="17" name="XR_LIP_EXPRESSION_CHEEK_PUFF_LEFT_HTC"/> + <enum value="18" name="XR_LIP_EXPRESSION_CHEEK_SUCK_HTC"/> + <enum value="19" name="XR_LIP_EXPRESSION_MOUTH_UPPER_UPRIGHT_HTC"/> + <enum value="20" name="XR_LIP_EXPRESSION_MOUTH_UPPER_UPLEFT_HTC"/> + <enum value="21" name="XR_LIP_EXPRESSION_MOUTH_LOWER_DOWNRIGHT_HTC"/> + <enum value="22" name="XR_LIP_EXPRESSION_MOUTH_LOWER_DOWNLEFT_HTC"/> + <enum value="23" name="XR_LIP_EXPRESSION_MOUTH_UPPER_INSIDE_HTC"/> + <enum value="24" name="XR_LIP_EXPRESSION_MOUTH_LOWER_INSIDE_HTC"/> + <enum value="25" name="XR_LIP_EXPRESSION_MOUTH_LOWER_OVERLAY_HTC"/> + <enum value="26" name="XR_LIP_EXPRESSION_TONGUE_LONGSTEP1_HTC"/> + <enum value="27" name="XR_LIP_EXPRESSION_TONGUE_LEFT_HTC"/> + <enum value="28" name="XR_LIP_EXPRESSION_TONGUE_RIGHT_HTC"/> + <enum value="29" name="XR_LIP_EXPRESSION_TONGUE_UP_HTC"/> + <enum value="30" name="XR_LIP_EXPRESSION_TONGUE_DOWN_HTC"/> + <enum value="31" name="XR_LIP_EXPRESSION_TONGUE_ROLL_HTC"/> + <enum value="32" name="XR_LIP_EXPRESSION_TONGUE_LONGSTEP2_HTC"/> + <enum value="33" name="XR_LIP_EXPRESSION_TONGUE_UPRIGHT_MORPH_HTC"/> + <enum value="34" name="XR_LIP_EXPRESSION_TONGUE_UPLEFT_MORPH_HTC"/> + <enum value="35" name="XR_LIP_EXPRESSION_TONGUE_DOWNRIGHT_MORPH_HTC"/> + <enum value="36" name="XR_LIP_EXPRESSION_TONGUE_DOWNLEFT_MORPH_HTC"/> + </enums> + + <!-- enums for XR_ANDROID_light_estimation --> + <enums name="XrLightEstimateStateANDROID" type="enum"> + <enum value="0" name="XR_LIGHT_ESTIMATE_STATE_VALID_ANDROID" comment="The light estimate is valid"/> + <enum value="1" name="XR_LIGHT_ESTIMATE_STATE_INVALID_ANDROID" comment="The light estimate is invalid"/> + </enums> + <enums name="XrSphericalHarmonicsKindANDROID" type="enum"> + <enum value="0" name="XR_SPHERICAL_HARMONICS_KIND_TOTAL_ANDROID" comment="The spherical harmonic coefficients represent the environment light radiance function, including the contribution from the main light."/> + <enum value="1" name="XR_SPHERICAL_HARMONICS_KIND_AMBIENT_ANDROID" comment="The spherical harmonic coefficients represent the environment light radiance function, excluding the contribution from the main light."/> + </enums> + + <!-- flags for XR_ALMALENCE_digital_lens_control --> + <enums name="XrDigitalLensControlFlagBitsALMALENCE" type="bitmask"> + <enum bitpos="0" name="XR_DIGITAL_LENS_CONTROL_PROCESSING_DISABLE_BIT_ALMALENCE" comment="disables Digital Lens processing of render textures"/> + </enums> + + <!-- flags for XR_FB_composition_layer_settings --> + <enums name="XrCompositionLayerSettingsFlagBitsFB" type="bitmask"> + <enum bitpos="0" name="XR_COMPOSITION_LAYER_SETTINGS_NORMAL_SUPER_SAMPLING_BIT_FB" comment="Indicates compositor may: use layer texture supersampling."/> + <enum bitpos="1" name="XR_COMPOSITION_LAYER_SETTINGS_QUALITY_SUPER_SAMPLING_BIT_FB" comment="Indicates compositor may: use high quality layer texture supersampling."/> + <enum bitpos="2" name="XR_COMPOSITION_LAYER_SETTINGS_NORMAL_SHARPENING_BIT_FB" comment="Indicates compositor may: use layer texture sharpening."/> + <enum bitpos="3" name="XR_COMPOSITION_LAYER_SETTINGS_QUALITY_SHARPENING_BIT_FB" comment="Indicates compositor may: use high quality layer texture sharpening."/> + </enums> + + <!-- flags for XR_OCULUS_external_camera --> + <enums name="XrExternalCameraStatusFlagBitsOCULUS" type="bitmask"> + <enum bitpos="0" name="XR_EXTERNAL_CAMERA_STATUS_CONNECTED_BIT_OCULUS" comment="External camera is connected"/> + <enum bitpos="1" name="XR_EXTERNAL_CAMERA_STATUS_CALIBRATING_BIT_OCULUS" comment="External camera is undergoing calibration"/> + <enum bitpos="2" name="XR_EXTERNAL_CAMERA_STATUS_CALIBRATION_FAILED_BIT_OCULUS" comment="External camera has tried and failed calibration"/> + <enum bitpos="3" name="XR_EXTERNAL_CAMERA_STATUS_CALIBRATED_BIT_OCULUS" comment="External camera has tried and passed calibration"/> + <enum bitpos="4" name="XR_EXTERNAL_CAMERA_STATUS_CAPTURING_BIT_OCULUS" comment="External camera is capturing"/> + </enums> + + <enums name="XrExternalCameraAttachedToDeviceOCULUS" type="enum"> + <enum value="0" name="XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_NONE_OCULUS" comment="External camera is at a fixed point in LOCAL space"/> + <enum value="1" name="XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_HMD_OCULUS" comment="External camera is attached to the HMD"/> + <enum value="2" name="XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_LTOUCH_OCULUS" comment="External camera is attached to a left Touch controller"/> + <enum value="3" name="XR_EXTERNAL_CAMERA_ATTACHED_TO_DEVICE_RTOUCH_OCULUS" comment="External camera is attached to a right Touch controller"/> + </enums> + + <!-- enums for XR_META_passthrough_color_lut--> + <enums name="XrPassthroughColorLutChannelsMETA" type="enum"> + <enum value="1" name="XR_PASSTHROUGH_COLOR_LUT_CHANNELS_RGB_META"/> + <enum value="2" name="XR_PASSTHROUGH_COLOR_LUT_CHANNELS_RGBA_META"/> + </enums> + + <!-- flags for XR_META_performance_metrics --> + <enums name="XrPerformanceMetricsCounterFlagBitsMETA" type="bitmask"> + <enum bitpos="0" name="XR_PERFORMANCE_METRICS_COUNTER_ANY_VALUE_VALID_BIT_META" comment="Indicates any of the values in XrPerformanceMetricsCounterMETA is valid."/> + <enum bitpos="1" name="XR_PERFORMANCE_METRICS_COUNTER_UINT_VALUE_VALID_BIT_META" comment="Indicates the uintValue in XrPerformanceMetricsCounterMETA is valid."/> + <enum bitpos="2" name="XR_PERFORMANCE_METRICS_COUNTER_FLOAT_VALUE_VALID_BIT_META" comment="Indicates the floatValue in XrPerformanceMetricsCounterMETA is valid."/> + </enums> + + <enums name="XrPerformanceMetricsCounterUnitMETA" type="enum"> + <enum value="0" name="XR_PERFORMANCE_METRICS_COUNTER_UNIT_GENERIC_META" comment="the performance counter unit is generic (unspecified)."/> + <enum value="1" name="XR_PERFORMANCE_METRICS_COUNTER_UNIT_PERCENTAGE_META" comment="the performance counter unit is percentage (%)."/> + <enum value="2" name="XR_PERFORMANCE_METRICS_COUNTER_UNIT_MILLISECONDS_META" comment="the performance counter unit is millisecond."/> + <enum value="3" name="XR_PERFORMANCE_METRICS_COUNTER_UNIT_BYTES_META" comment="the performance counter unit is byte."/> + <enum value="4" name="XR_PERFORMANCE_METRICS_COUNTER_UNIT_HERTZ_META" comment="the performance counter unit is hertz (Hz)."/> + </enums> + + <!-- flags for XR_META_passthrough_preferences --> + <enums name="XrPassthroughPreferenceFlagBitsMETA" type="bitmask"> + <enum bitpos="0" name="XR_PASSTHROUGH_PREFERENCE_DEFAULT_TO_ACTIVE_BIT_META" comment="Indicates that the runtime recommends apps to default to a mixed reality experience with passthrough (if supported)."/> + </enums> + + <!-- enums for XR_HTC_foveation --> + <enums name="XrFoveationModeHTC" type="enum"> + <enum value="0" name="XR_FOVEATION_MODE_DISABLE_HTC" comment="No foveation"/> + <enum value="1" name="XR_FOVEATION_MODE_FIXED_HTC" comment="Apply system default setting with fixed clear FOV and periphery quality."/> + <enum value="2" name="XR_FOVEATION_MODE_DYNAMIC_HTC" comment="Allow system to set foveation dynamically according realtime system metric or other extensions."/> + <enum value="3" name="XR_FOVEATION_MODE_CUSTOM_HTC" comment="Allow application to set foveation with desired clear FOV, periphery quality, and focal center offset."/> + </enums> + <enums name="XrFoveationDynamicFlagBitsHTC" type="bitmask"> + <enum bitpos="0" name="XR_FOVEATION_DYNAMIC_LEVEL_ENABLED_BIT_HTC" comment="Allow system to set periphery pixel density dynamically."/> + <enum bitpos="1" name="XR_FOVEATION_DYNAMIC_CLEAR_FOV_ENABLED_BIT_HTC" comment="Allow system to set clear FOV degree dynamically."/> + <enum bitpos="2" name="XR_FOVEATION_DYNAMIC_FOCAL_CENTER_OFFSET_ENABLED_BIT_HTC" comment="Allow system to set focal center offset dynamically."/> + </enums> + <enums name="XrFoveationLevelHTC" type="enum"> + <enum value="0" name="XR_FOVEATION_LEVEL_NONE_HTC" comment="No foveation"/> + <enum value="1" name="XR_FOVEATION_LEVEL_LOW_HTC" comment="Light periphery pixel density drop and lower performance gain."/> + <enum value="2" name="XR_FOVEATION_LEVEL_MEDIUM_HTC" comment="Medium periphery pixel density drop and medium performance gain"/> + <enum value="3" name="XR_FOVEATION_LEVEL_HIGH_HTC" comment="Heavy periphery pixel density drop and higher performance gain"/> + </enums> + + <!-- XR_HTC_body_tracking --> + <enums name="XrBodyJointHTC" type="enum"> + <enum value="0" name="XR_BODY_JOINT_PELVIS_HTC"/> + <enum value="1" name="XR_BODY_JOINT_LEFT_HIP_HTC"/> + <enum value="2" name="XR_BODY_JOINT_LEFT_KNEE_HTC"/> + <enum value="3" name="XR_BODY_JOINT_LEFT_ANKLE_HTC"/> + <enum value="4" name="XR_BODY_JOINT_LEFT_FEET_HTC"/> + <enum value="5" name="XR_BODY_JOINT_RIGHT_HIP_HTC"/> + <enum value="6" name="XR_BODY_JOINT_RIGHT_KNEE_HTC"/> + <enum value="7" name="XR_BODY_JOINT_RIGHT_ANKLE_HTC"/> + <enum value="8" name="XR_BODY_JOINT_RIGHT_FEET_HTC"/> + <enum value="9" name="XR_BODY_JOINT_WAIST_HTC"/> + <enum value="10" name="XR_BODY_JOINT_SPINE_LOWER_HTC"/> + <enum value="11" name="XR_BODY_JOINT_SPINE_MIDDLE_HTC"/> + <enum value="12" name="XR_BODY_JOINT_SPINE_HIGH_HTC"/> + <enum value="13" name="XR_BODY_JOINT_CHEST_HTC"/> + <enum value="14" name="XR_BODY_JOINT_NECK_HTC"/> + <enum value="15" name="XR_BODY_JOINT_HEAD_HTC"/> + <enum value="16" name="XR_BODY_JOINT_LEFT_CLAVICLE_HTC"/> + <enum value="17" name="XR_BODY_JOINT_LEFT_SCAPULA_HTC"/> + <enum value="18" name="XR_BODY_JOINT_LEFT_ARM_HTC"/> + <enum value="19" name="XR_BODY_JOINT_LEFT_ELBOW_HTC"/> + <enum value="20" name="XR_BODY_JOINT_LEFT_WRIST_HTC"/> + <enum value="21" name="XR_BODY_JOINT_RIGHT_CLAVICLE_HTC"/> + <enum value="22" name="XR_BODY_JOINT_RIGHT_SCAPULA_HTC"/> + <enum value="23" name="XR_BODY_JOINT_RIGHT_ARM_HTC"/> + <enum value="24" name="XR_BODY_JOINT_RIGHT_ELBOW_HTC"/> + <enum value="25" name="XR_BODY_JOINT_RIGHT_WRIST_HTC"/> + </enums> + <enums name="XrBodyJointSetHTC" type="enum"> + <enum value="0" name="XR_BODY_JOINT_SET_FULL_HTC"/> + </enums> + + <enums name="XrBodyJointConfidenceHTC" type="enum"> + <enum value="0" name="XR_BODY_JOINT_CONFIDENCE_NONE_HTC"/> + <enum value="1" name="XR_BODY_JOINT_CONFIDENCE_LOW_HTC"/> + <enum value="2" name="XR_BODY_JOINT_CONFIDENCE_HIGH_HTC"/> + </enums> + + <!-- enums for XR_ANDROID_performance_metrics --> + <enums name="XrPerformanceMetricsCounterUnitANDROID" type="enum"> + <enum value="0" name="XR_PERFORMANCE_METRICS_COUNTER_UNIT_GENERIC_ANDROID" comment="The performance counter unit is generic (unspecified)."/> + <enum value="1" name="XR_PERFORMANCE_METRICS_COUNTER_UNIT_PERCENTAGE_ANDROID" comment="The performance counter unit is percentage (%)."/> + <enum value="2" name="XR_PERFORMANCE_METRICS_COUNTER_UNIT_MILLISECONDS_ANDROID" comment="The performance counter unit is millisecond."/> + <enum value="3" name="XR_PERFORMANCE_METRICS_COUNTER_UNIT_BYTES_ANDROID" comment="The performance counter unit is byte."/> + <enum value="4" name="XR_PERFORMANCE_METRICS_COUNTER_UNIT_HERTZ_ANDROID" comment="The performance counter unit is hertz (Hz)."/> + </enums> + <enums name="XrPerformanceMetricsCounterFlagBitsANDROID" type="bitmask"> + <enum bitpos="0" name="XR_PERFORMANCE_METRICS_COUNTER_ANY_VALUE_VALID_BIT_ANDROID" comment="Indicates any of the values in XrPerformanceMetricsCounterANDROID is valid."/> + <enum bitpos="1" name="XR_PERFORMANCE_METRICS_COUNTER_UINT_VALUE_VALID_BIT_ANDROID" comment="Indicates the uintValue in XrPerformanceMetricsCounterANDROID is valid."/> + <enum bitpos="2" name="XR_PERFORMANCE_METRICS_COUNTER_FLOAT_VALUE_VALID_BIT_ANDROID" comment="Indicates the floatValue in XrPerformanceMetricsCounterANDROID is valid."/> + </enums> + + <!-- enums for XR_FB_composition_layer_depth_test --> + <enums name="XrCompareOpFB" type="enum"> + <enum value="0" name="XR_COMPARE_OP_NEVER_FB" comment="Comparison is never true."/> + <enum value="1" name="XR_COMPARE_OP_LESS_FB" comment="Comparison is true if source less than is destination."/> + <enum value="2" name="XR_COMPARE_OP_EQUAL_FB" comment="Comparison is true if source is equal to destination."/> + <enum value="3" name="XR_COMPARE_OP_LESS_OR_EQUAL_FB" comment="Comparison is true if source is less than or equal to destination."/> + <enum value="4" name="XR_COMPARE_OP_GREATER_FB" comment="Comparison is true if source is greater than destination."/> + <enum value="5" name="XR_COMPARE_OP_NOT_EQUAL_FB" comment="Comparison is true if source is not equal to destination."/> + <enum value="6" name="XR_COMPARE_OP_GREATER_OR_EQUAL_FB" comment="Comparison is true if source is greater than or equal to destination."/> + <enum value="7" name="XR_COMPARE_OP_ALWAYS_FB" comment="Comparison is always true."/> + </enums> + + <!-- enums for XR_ANDROID_face_tracking --> + <enums name="XrFaceParameterIndicesANDROID" type="enum"> + <enum value="0" name="XR_FACE_PARAMETER_INDICES_BROW_LOWERER_L_ANDROID" comment="The left brow lowerer blendshape parameter."/> + <enum value="1" name="XR_FACE_PARAMETER_INDICES_BROW_LOWERER_R_ANDROID" comment="The right brow lowerer blendshape parameter."/> + <enum value="2" name="XR_FACE_PARAMETER_INDICES_CHEEK_PUFF_L_ANDROID" comment="The left cheek puff blendshape parameter."/> + <enum value="3" name="XR_FACE_PARAMETER_INDICES_CHEEK_PUFF_R_ANDROID" comment="The right cheek puff blendshape parameter."/> + <enum value="4" name="XR_FACE_PARAMETER_INDICES_CHEEK_RAISER_L_ANDROID" comment="The left cheek raiser blendshape parameter."/> + <enum value="5" name="XR_FACE_PARAMETER_INDICES_CHEEK_RAISER_R_ANDROID" comment="The right cheek raiser blendshape parameter."/> + <enum value="6" name="XR_FACE_PARAMETER_INDICES_CHEEK_SUCK_L_ANDROID" comment="The left cheek suck blendshape parameter."/> + <enum value="7" name="XR_FACE_PARAMETER_INDICES_CHEEK_SUCK_R_ANDROID" comment="The right cheek suck blendshape parameter."/> + <enum value="8" name="XR_FACE_PARAMETER_INDICES_CHIN_RAISER_B_ANDROID" comment="The bottom chin raiser blendshape parameter."/> + <enum value="9" name="XR_FACE_PARAMETER_INDICES_CHIN_RAISER_T_ANDROID" comment="The top chin raiser blendshape parameter."/> + <enum value="10" name="XR_FACE_PARAMETER_INDICES_DIMPLER_L_ANDROID" comment="The left dimpler blendshape parameter."/> + <enum value="11" name="XR_FACE_PARAMETER_INDICES_DIMPLER_R_ANDROID" comment="The right dimpler lowerer blendshape parameter."/> + <enum value="12" name="XR_FACE_PARAMETER_INDICES_EYES_CLOSED_L_ANDROID" comment="The left eyes closed blendshape parameter."/> + <enum value="13" name="XR_FACE_PARAMETER_INDICES_EYES_CLOSED_R_ANDROID" comment="The right eyes closed blendshape parameter."/> + <enum value="14" name="XR_FACE_PARAMETER_INDICES_EYES_LOOK_DOWN_L_ANDROID" comment="The left eyes look down blendshape parameter."/> + <enum value="15" name="XR_FACE_PARAMETER_INDICES_EYES_LOOK_DOWN_R_ANDROID" comment="The right eyes look down blendshape parameter."/> + <enum value="16" name="XR_FACE_PARAMETER_INDICES_EYES_LOOK_LEFT_L_ANDROID" comment="The left look left blendshape parameter."/> + <enum value="17" name="XR_FACE_PARAMETER_INDICES_EYES_LOOK_LEFT_R_ANDROID" comment="The left look right blendshape parameter."/> + <enum value="18" name="XR_FACE_PARAMETER_INDICES_EYES_LOOK_RIGHT_L_ANDROID" comment="The right look left blendshape parameter."/> + <enum value="19" name="XR_FACE_PARAMETER_INDICES_EYES_LOOK_RIGHT_R_ANDROID" comment="The right look right blendshape parameter."/> + <enum value="20" name="XR_FACE_PARAMETER_INDICES_EYES_LOOK_UP_L_ANDROID" comment="The left eyes look up blendshape parameter."/> + <enum value="21" name="XR_FACE_PARAMETER_INDICES_EYES_LOOK_UP_R_ANDROID" comment="The right eyes look up blendshape parameter."/> + <enum value="22" name="XR_FACE_PARAMETER_INDICES_INNER_BROW_RAISER_L_ANDROID" comment="The left inner brow raiser blendshape parameter."/> + <enum value="23" name="XR_FACE_PARAMETER_INDICES_INNER_BROW_RAISER_R_ANDROID" comment="The right inner brow raiser blendshape parameter."/> + <enum value="24" name="XR_FACE_PARAMETER_INDICES_JAW_DROP_ANDROID" comment="The jaw drop blendshape parameter."/> + <enum value="25" name="XR_FACE_PARAMETER_INDICES_JAW_SIDEWAYS_LEFT_ANDROID" comment="The left jaw sideways blendshape parameter."/> + <enum value="26" name="XR_FACE_PARAMETER_INDICES_JAW_SIDEWAYS_RIGHT_ANDROID" comment="The right jaw sideways blendshape parameter."/> + <enum value="27" name="XR_FACE_PARAMETER_INDICES_JAW_THRUST_ANDROID" comment="The jaw thrust blendshape parameter."/> + <enum value="28" name="XR_FACE_PARAMETER_INDICES_LID_TIGHTENER_L_ANDROID" comment="The left lid tightener blendshape parameter."/> + <enum value="29" name="XR_FACE_PARAMETER_INDICES_LID_TIGHTENER_R_ANDROID" comment="The right lid tightener blendshape parameter."/> + <enum value="30" name="XR_FACE_PARAMETER_INDICES_LIP_CORNER_DEPRESSOR_L_ANDROID" comment="The left corner lip depressor blendshape parameter."/> + <enum value="31" name="XR_FACE_PARAMETER_INDICES_LIP_CORNER_DEPRESSOR_R_ANDROID" comment="The right corner lip depressor blendshape parameter."/> + <enum value="32" name="XR_FACE_PARAMETER_INDICES_LIP_CORNER_PULLER_L_ANDROID" comment="The left corner lip puller blendshape parameter."/> + <enum value="33" name="XR_FACE_PARAMETER_INDICES_LIP_CORNER_PULLER_R_ANDROID" comment="The right corner lip puller blendshape parameter."/> + <enum value="34" name="XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_LB_ANDROID" comment="The left bottom lip funneler blendshape parameter."/> + <enum value="35" name="XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_LT_ANDROID" comment="The left top lip funneler blendshape parameter."/> + <enum value="36" name="XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_RB_ANDROID" comment="The right bottom lip funneler blendshape parameter."/> + <enum value="37" name="XR_FACE_PARAMETER_INDICES_LIP_FUNNELER_RT_ANDROID" comment="The right top lip funneler blendshape parameter."/> + <enum value="38" name="XR_FACE_PARAMETER_INDICES_LIP_PRESSOR_L_ANDROID" comment="The left lip pressor blendshape parameter."/> + <enum value="39" name="XR_FACE_PARAMETER_INDICES_LIP_PRESSOR_R_ANDROID" comment="The right lip pressor blendshape parameter."/> + <enum value="40" name="XR_FACE_PARAMETER_INDICES_LIP_PUCKER_L_ANDROID" comment="The left lip pucker blendshape parameter."/> + <enum value="41" name="XR_FACE_PARAMETER_INDICES_LIP_PUCKER_R_ANDROID" comment="The right lip pucker blendshape parameter."/> + <enum value="42" name="XR_FACE_PARAMETER_INDICES_LIP_STRETCHER_L_ANDROID" comment="The left lip stretcher blendshape parameter."/> + <enum value="43" name="XR_FACE_PARAMETER_INDICES_LIP_STRETCHER_R_ANDROID" comment="The right lip stretcher blendshape parameter."/> + <enum value="44" name="XR_FACE_PARAMETER_INDICES_LIP_SUCK_LB_ANDROID" comment="The left bottom lip suck blendshape parameter."/> + <enum value="45" name="XR_FACE_PARAMETER_INDICES_LIP_SUCK_LT_ANDROID" comment="The left top lip suck blendshape parameter."/> + <enum value="46" name="XR_FACE_PARAMETER_INDICES_LIP_SUCK_RB_ANDROID" comment="The right bottom lip suck blendshape parameter."/> + <enum value="47" name="XR_FACE_PARAMETER_INDICES_LIP_SUCK_RT_ANDROID" comment="The right top lip suck blendshape parameter."/> + <enum value="48" name="XR_FACE_PARAMETER_INDICES_LIP_TIGHTENER_L_ANDROID" comment="The left lip tightener blendshape parameter."/> + <enum value="49" name="XR_FACE_PARAMETER_INDICES_LIP_TIGHTENER_R_ANDROID" comment="The right lip tightener blendshape parameter."/> + <enum value="50" name="XR_FACE_PARAMETER_INDICES_LIPS_TOWARD_ANDROID" comment="The lips toward blendshape parameter."/> + <enum value="51" name="XR_FACE_PARAMETER_INDICES_LOWER_LIP_DEPRESSOR_L_ANDROID" comment="The left lower lip depressor blendshape parameter."/> + <enum value="52" name="XR_FACE_PARAMETER_INDICES_LOWER_LIP_DEPRESSOR_R_ANDROID" comment="The right lower lip depressor blendshape parameter."/> + <enum value="53" name="XR_FACE_PARAMETER_INDICES_MOUTH_LEFT_ANDROID" comment="The mouth move left blendshape parameter."/> + <enum value="54" name="XR_FACE_PARAMETER_INDICES_MOUTH_RIGHT_ANDROID" comment="The mouth move right blendshape parameter."/> + <enum value="55" name="XR_FACE_PARAMETER_INDICES_NOSE_WRINKLER_L_ANDROID" comment="The left nose wrinkler blendshape parameter."/> + <enum value="56" name="XR_FACE_PARAMETER_INDICES_NOSE_WRINKLER_R_ANDROID" comment="The right nose wrinkler blendshape parameter."/> + <enum value="57" name="XR_FACE_PARAMETER_INDICES_OUTER_BROW_RAISER_L_ANDROID" comment="The left outer brow raiser blendshape parameter."/> + <enum value="58" name="XR_FACE_PARAMETER_INDICES_OUTER_BROW_RAISER_R_ANDROID" comment="The right outer brow raiser blendshape parameter."/> + <enum value="59" name="XR_FACE_PARAMETER_INDICES_UPPER_LID_RAISER_L_ANDROID" comment="The left lid raiser blendshape parameter."/> + <enum value="60" name="XR_FACE_PARAMETER_INDICES_UPPER_LID_RAISER_R_ANDROID" comment="The right lid raiser blendshape parameter."/> + <enum value="61" name="XR_FACE_PARAMETER_INDICES_UPPER_LIP_RAISER_L_ANDROID" comment="The left lip raiser blendshape parameter."/> + <enum value="62" name="XR_FACE_PARAMETER_INDICES_UPPER_LIP_RAISER_R_ANDROID" comment="The right lip raiser blendshape parameter."/> + <enum value="63" name="XR_FACE_PARAMETER_INDICES_TONGUE_OUT_ANDROID" comment="The tongue out blendshape parameter."/> + <enum value="64" name="XR_FACE_PARAMETER_INDICES_TONGUE_LEFT_ANDROID" comment="The tongue left puller blendshape parameter."/> + <enum value="65" name="XR_FACE_PARAMETER_INDICES_TONGUE_RIGHT_ANDROID" comment="The right right puller blendshape parameter."/> + <enum value="66" name="XR_FACE_PARAMETER_INDICES_TONGUE_UP_ANDROID" comment="The right up puller blendshape parameter."/> + <enum value="67" name="XR_FACE_PARAMETER_INDICES_TONGUE_DOWN_ANDROID" comment="The right down puller blendshape parameter."/> + </enums> + <enums name="XrFaceTrackingStateANDROID" type="enum"> + <enum value="0" name="XR_FACE_TRACKING_STATE_PAUSED_ANDROID" comment="Indicates that face tracking is paused but may be resumed in the future."/> + <enum value="1" name="XR_FACE_TRACKING_STATE_STOPPED_ANDROID" comment="Tracking has stopped but the client still has an active face tracker."/> + <enum value="2" name="XR_FACE_TRACKING_STATE_TRACKING_ANDROID" comment="The face is currently tracked and its pose is current."/> + </enums> + <enums name="XrFaceConfidenceRegionsANDROID" type="enum"> + <enum value="0" name="XR_FACE_CONFIDENCE_REGIONS_LOWER_ANDROID" comment="Confidence corresponding to the lower region."/> + <enum value="1" name="XR_FACE_CONFIDENCE_REGIONS_LEFT_UPPER_ANDROID" comment="Confidence corresponding to the left upper region."/> + <enum value="2" name="XR_FACE_CONFIDENCE_REGIONS_RIGHT_UPPER_ANDROID" comment="Confidence corresponding to the right upper region."/> + </enums> + + <!-- enums for XR_ANDROID_passthrough_camera_state--> + <enums name="XrPassthroughCameraStateANDROID" type="enum"> + <enum value="0" name="XR_PASSTHROUGH_CAMERA_STATE_DISABLED_ANDROID" comment="The camera has been disabled by an app, the system or the user."/> + <enum value="1" name="XR_PASSTHROUGH_CAMERA_STATE_INITIALIZING_ANDROID" comment="The camera is still coming online and not yet ready to use. The runtime may: render a black background where the passthrough video is supposed to appear."/> + <enum value="2" name="XR_PASSTHROUGH_CAMERA_STATE_READY_ANDROID" comment="The camera is ready to use."/> + <enum value="3" name="XR_PASSTHROUGH_CAMERA_STATE_ERROR_ANDROID" comment="The camera is in an unrecoverable error state."/> + </enums> + + <!-- enums for XR_ANDROID_trackables_object --> + <enums name="XrObjectLabelANDROID" type="enum"> + <enum value="0" name="XR_OBJECT_LABEL_UNKNOWN_ANDROID" comment="It was not possible to label the object."/> + <enum value="1" name="XR_OBJECT_LABEL_KEYBOARD_ANDROID" comment="The object is a keyboard."/> + <enum value="2" name="XR_OBJECT_LABEL_MOUSE_ANDROID" comment="The object is a mouse."/> + <enum value="3" name="XR_OBJECT_LABEL_LAPTOP_ANDROID" comment="The object is a laptop."/> + </enums> + + <!-- enums for XR_ANDROID_trackables_marker --> + <enums name="XrTrackableMarkerTrackingModeANDROID" type="enum"> + <enum value="0" name="XR_TRACKABLE_MARKER_TRACKING_MODE_DYNAMIC_ANDROID" comment="Tracking dynamic markers. This mode has the highest accuracy and works on moving and static markers, but also has the highest power consumption."/> + <enum value="1" name="XR_TRACKABLE_MARKER_TRACKING_MODE_STATIC_ANDROID" comment="Tracking static markers. This mode is primarily useful for markers that are known to be static, which leads to less power consumption in comparison to the dynamic mode."/> + </enums> + <enums name="XrTrackableMarkerDictionaryANDROID" type="enum"> + <enum value="0" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_50_ANDROID"/> + <enum value="1" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_100_ANDROID"/> + <enum value="2" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_250_ANDROID"/> + <enum value="3" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_4X4_1000_ANDROID"/> + <enum value="4" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_50_ANDROID"/> + <enum value="5" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_100_ANDROID"/> + <enum value="6" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_250_ANDROID"/> + <enum value="7" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_5X5_1000_ANDROID"/> + <enum value="8" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_50_ANDROID"/> + <enum value="9" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_100_ANDROID"/> + <enum value="10" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_250_ANDROID"/> + <enum value="11" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_6X6_1000_ANDROID"/> + <enum value="12" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_50_ANDROID"/> + <enum value="13" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_100_ANDROID"/> + <enum value="14" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_250_ANDROID"/> + <enum value="15" name="XR_TRACKABLE_MARKER_DICTIONARY_ARUCO_7X7_1000_ANDROID"/> + <enum value="16" name="XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_16H5_ANDROID"/> + <enum value="17" name="XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_25H9_ANDROID"/> + <enum value="18" name="XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_36H10_ANDROID"/> + <enum value="19" name="XR_TRACKABLE_MARKER_DICTIONARY_APRILTAG_36H11_ANDROID"/> + </enums> + + <!-- enums for XR_ANDROID_device_anchor_persistence --> + <enums name="XrAnchorPersistStateANDROID" type="enum"> + <enum value="0" name="XR_ANCHOR_PERSIST_STATE_PERSIST_NOT_REQUESTED_ANDROID" comment="Anchor has not been requested to be persisted by the app."/> + <enum value="1" name="XR_ANCHOR_PERSIST_STATE_PERSIST_PENDING_ANDROID" comment="Anchor has been requested to be persisted but not persisted yet."/> + <enum value="2" name="XR_ANCHOR_PERSIST_STATE_PERSISTED_ANDROID" comment="Anchor has been successfully persisted by the runtime."/> + </enums> + + <!-- enums for XR_ANDROID_trackables_qr_code --> + <enums name="XrQrCodeTrackingModeANDROID" type="enum"> + <enum value="0" name="XR_QR_CODE_TRACKING_MODE_DYNAMIC_ANDROID" comment="Tracking dynamic QR codes. This mode has the highest accuracy and works on moving and static QR codes, but also has the highest power consumption."/> + <enum value="1" name="XR_QR_CODE_TRACKING_MODE_STATIC_ANDROID" comment="Tracking static QR codes. This mode is primarily useful for QR codes that are known to be static, which leads to less power consumption in comparison to the dynamic mode."/> + </enums> + + <!-- enums for XR_ANDROID_composition_layer_passthrough_mesh --> + <enums name="XrWindingOrderANDROID" type="enum"> + <enum value="0" name="XR_WINDING_ORDER_UNKNOWN_ANDROID" comment="Winding order of the mesh's triangles is not known."/> + <enum value="1" name="XR_WINDING_ORDER_CW_ANDROID" comment="Winding order of the mesh's triangles is clockwise."/> + <enum value="2" name="XR_WINDING_ORDER_CCW_ANDROID" comment="Winding order of the mesh's triangles is counter-clockwise."/> + </enums> + + <!-- enums for XR_ANDROID_scene_meshing --> + <enums name="XrSceneMeshSemanticLabelSetANDROID" type="enum"> + <enum value="0" name="XR_SCENE_MESH_SEMANTIC_LABEL_SET_NONE_ANDROID" comment="This semantic label set represents absence of semantic labels."/> + <enum value="1" name="XR_SCENE_MESH_SEMANTIC_LABEL_SET_DEFAULT_ANDROID" comment="This semantic label set represents XrSceneMeshSemanticLabelANDROID."/> + </enums> + <enums name="XrSceneMeshSemanticLabelANDROID" type="enum"> + <enum value="0" name="XR_SCENE_MESH_SEMANTIC_LABEL_OTHER_ANDROID" comment="This semantic label indicates that the corresponding mesh element represents an unknown object."/> + <enum value="1" name="XR_SCENE_MESH_SEMANTIC_LABEL_FLOOR_ANDROID" comment="This semantic label indicates that the corresponding mesh element represents a floor."/> + <enum value="2" name="XR_SCENE_MESH_SEMANTIC_LABEL_CEILING_ANDROID" comment="This semantic label indicates that the corresponding mesh element represents a ceiling."/> + <enum value="3" name="XR_SCENE_MESH_SEMANTIC_LABEL_WALL_ANDROID" comment="This semantic label indicates that the corresponding mesh element represents a wall."/> + <enum value="4" name="XR_SCENE_MESH_SEMANTIC_LABEL_TABLE_ANDROID" comment="This semantic label indicates that the corresponding mesh element represents a table."/> + </enums> + <enums name="XrSceneMeshTrackingStateANDROID" type="enum"> + <enum value="0" name="XR_SCENE_MESH_TRACKING_STATE_INITIALIZING_ANDROID" comment="The tracker is not yet ready to provide mesh data."/> + <enum value="1" name="XR_SCENE_MESH_TRACKING_STATE_TRACKING_ANDROID" comment="The tracker is actively tracking."/> + <enum value="2" name="XR_SCENE_MESH_TRACKING_STATE_WAITING_ANDROID" comment="The tracker is waiting for valid measurements to integrate since the last mesh update."/> + <enum value="3" name="XR_SCENE_MESH_TRACKING_STATE_ERROR_ANDROID" comment="The tracker has not received valid measurements for multiple cycles and is in an error state."/> + </enums> + + <!-- enums for XR_ANDROID_eye_tracking --> + <enums name="XrEyeIndexANDROID" type="enum"> + <enum value="0" name="XR_EYE_INDEX_LEFT_ANDROID" comment="Left eye."/> + <enum value="1" name="XR_EYE_INDEX_RIGHT_ANDROID" comment="Right eye."/> + </enums> + <enums name="XrEyeStateANDROID" type="enum"> + <enum value="0" name="XR_EYE_STATE_INVALID_ANDROID" comment="Indicates that the eye is in an error state or not present."/> + <enum value="1" name="XR_EYE_STATE_GAZING_ANDROID" comment="Indicates that the eye is currently gazing."/> + <enum value="2" name="XR_EYE_STATE_SHUT_ANDROID" comment="Indicates that the eye is currently shut due to a wink or a blink."/> + </enums> + <enums name="XrEyeTrackingModeANDROID" type="enum"> + <enum value="0" name="XR_EYE_TRACKING_MODE_NOT_TRACKING_ANDROID" comment="Indicates that eye tracking is not currently active."/> + <enum value="1" name="XR_EYE_TRACKING_MODE_RIGHT_ANDROID" comment="Indicates that only the right eye is tracking."/> + <enum value="2" name="XR_EYE_TRACKING_MODE_LEFT_ANDROID" comment="Indicates that only the left eye is tracking."/> + <enum value="3" name="XR_EYE_TRACKING_MODE_BOTH_ANDROID" comment="Indicates that both the left and right eyes are tracking."/> + </enums> + + <!-- enums for XR_ML_frame_end_info --> + <enums name="XrFrameEndInfoFlagBitsML" type="bitmask"> + <enum bitpos="0" name="XR_FRAME_END_INFO_PROTECTED_BIT_ML" comment="Indicates that the content for this frame is protected and should not be recorded or captured outside the graphics system."/> + <enum bitpos="1" name="XR_FRAME_END_INFO_VIGNETTE_BIT_ML" comment="Indicates that a soft fade to transparent should be added to the frame in the compositor to blend any hard edges at the FOV limits."/> + </enums> + + <!-- enums for XR_ML_global_dimmer --> + <enums name="XrGlobalDimmerFrameEndInfoFlagBitsML" type="bitmask"> + <enum bitpos="0" name="XR_GLOBAL_DIMMER_FRAME_END_INFO_ENABLED_BIT_ML" comment="Indicates that the global dimmer should: be enabled and controlled by slink:XrGlobalDimmerFrameEndInfoML::pname:dimmerValue."/> + </enums> + + <!-- enums for XR_QCOM_tracking_optimization_settings --> + <enums name="XrTrackingOptimizationSettingsHintQCOM" type="enum"> + <enum value="0" name="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_NONE_QCOM" comment="Used by the application to indicate that it does not have a preference to optimize for. The run-time is understood to choose a balanced approach."/> + <enum value="1" name="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LONG_RANGE_PRIORITIZATION_QCOM" comment="Used by the application to indicate that it prefers tracking to be optimized for long range, possibly at the expense of competing interests."/> + <enum value="2" name="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_CLOSE_RANGE_PRIORITIZATION_QCOM" comment="Used by the application to indicate that it prefers tracking to be optimized for close range, possibly at the expense of competing interests."/> + <enum value="3" name="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LOW_POWER_PRIORITIZATION_QCOM" comment="Used by the application to indicate that it prefers tracking to be optimized for low power consumption, possibly at the expense of competing interests."/> + <enum value="4" name="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_HIGH_POWER_PRIORITIZATION_QCOM" comment="Used by the application to indicate that it prefers tracking to be optimized for increased tracking performance, possibly at the cost of increased power consumption."/> + </enums> + + <enums name="XrTrackingOptimizationSettingsDomainQCOM" type="enum"> + <enum value="1" name="XR_TRACKING_OPTIMIZATION_SETTINGS_DOMAIN_ALL_QCOM" comment="Setting applies to all QCOM tracking extensions."/> + </enums> + + <!-- enums for XR_MNDX_force_feedback_curl --> + <enums name="XrForceFeedbackCurlLocationMNDX" type="enum"> + <enum value="0" name="XR_FORCE_FEEDBACK_CURL_LOCATION_THUMB_CURL_MNDX" comment="force feedback for thumb curl"/> + <enum value="1" name="XR_FORCE_FEEDBACK_CURL_LOCATION_INDEX_CURL_MNDX" comment="force feedback for index finger curl"/> + <enum value="2" name="XR_FORCE_FEEDBACK_CURL_LOCATION_MIDDLE_CURL_MNDX" comment="force feedback for middle finger curl"/> + <enum value="3" name="XR_FORCE_FEEDBACK_CURL_LOCATION_RING_CURL_MNDX" comment="force feedback for ring finger curl"/> + <enum value="4" name="XR_FORCE_FEEDBACK_CURL_LOCATION_LITTLE_CURL_MNDX" comment="force feedback for little finger curl"/> + </enums> + + <!-- enums XR_EXT_plane_detection --> + <enums name="XrPlaneDetectorFlagBitsEXT" type="bitmask"> + <enum bitpos="0" name="XR_PLANE_DETECTOR_ENABLE_CONTOUR_BIT_EXT" comment="populate the plane contour information"/> + </enums> + + <enums name="XrPlaneDetectionCapabilityFlagBitsEXT" type="bitmask"> + <enum bitpos="0" name="XR_PLANE_DETECTION_CAPABILITY_PLANE_DETECTION_BIT_EXT" comment="plane detection is supported"/> + <enum bitpos="1" name="XR_PLANE_DETECTION_CAPABILITY_PLANE_HOLES_BIT_EXT" comment="polygon buffers for holes in planes can be generated"/> + <enum bitpos="2" name="XR_PLANE_DETECTION_CAPABILITY_SEMANTIC_CEILING_BIT_EXT" comment="plane detection supports ceiling semantic classification"/> + <enum bitpos="3" name="XR_PLANE_DETECTION_CAPABILITY_SEMANTIC_FLOOR_BIT_EXT" comment="plane detection supports floor semantic classification"/> + <enum bitpos="4" name="XR_PLANE_DETECTION_CAPABILITY_SEMANTIC_WALL_BIT_EXT" comment="plane detection supports wall semantic classification"/> + <enum bitpos="5" name="XR_PLANE_DETECTION_CAPABILITY_SEMANTIC_PLATFORM_BIT_EXT" comment="plane detection supports platform semantic classification (for example table tops)"/> + <enum bitpos="6" name="XR_PLANE_DETECTION_CAPABILITY_ORIENTATION_BIT_EXT" comment="plane detection supports plane orientation classification. If not supported planes are always classified as ARBITRARY."/> + </enums> + + <enums name="XrPlaneDetectionStateEXT" type="enum"> + <enum value="0" name="XR_PLANE_DETECTION_STATE_NONE_EXT"/> + <enum value="1" name="XR_PLANE_DETECTION_STATE_PENDING_EXT"/> + <enum value="2" name="XR_PLANE_DETECTION_STATE_DONE_EXT"/> + <enum value="3" name="XR_PLANE_DETECTION_STATE_ERROR_EXT"/> + <enum value="4" name="XR_PLANE_DETECTION_STATE_FATAL_EXT"/> + </enums> + + <enums name="XrPlaneDetectorOrientationEXT" type="enum"> + <enum value="0" name="XR_PLANE_DETECTOR_ORIENTATION_HORIZONTAL_UPWARD_EXT" comment="The detected plane is horizontal and faces upward (e.g. floor)."/> + <enum value="1" name="XR_PLANE_DETECTOR_ORIENTATION_HORIZONTAL_DOWNWARD_EXT" comment="The detected plane is horizontal and faces downward (e.g. ceiling)."/> + <enum value="2" name="XR_PLANE_DETECTOR_ORIENTATION_VERTICAL_EXT" comment="The detected plane is vertical (e.g. wall)."/> + <enum value="3" name="XR_PLANE_DETECTOR_ORIENTATION_ARBITRARY_EXT" comment="The detected plane has an arbitrary, non-vertical and non-horizontal orientation."/> + </enums> + + <enums name="XrPlaneDetectorSemanticTypeEXT" type="enum"> + <enum value="0" name="XR_PLANE_DETECTOR_SEMANTIC_TYPE_UNDEFINED_EXT" comment="The runtime was unable to classify this plane."/> + <enum value="1" name="XR_PLANE_DETECTOR_SEMANTIC_TYPE_CEILING_EXT" comment="The detected plane is a ceiling."/> + <enum value="2" name="XR_PLANE_DETECTOR_SEMANTIC_TYPE_FLOOR_EXT" comment="The detected plane is a floor."/> + <enum value="3" name="XR_PLANE_DETECTOR_SEMANTIC_TYPE_WALL_EXT" comment="The detected plane is a wall."/> + <enum value="4" name="XR_PLANE_DETECTOR_SEMANTIC_TYPE_PLATFORM_EXT" comment="The detected plane is a platform, like a table."/> + </enums> + + <!-- enums for XR_META_virtual_keyboard --> + <enums name="XrVirtualKeyboardLocationTypeMETA" type="enum"> + <enum value="0" name="XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_CUSTOM_META" comment="Indicates that the application will provide the position and scale of the keyboard."/> + <enum value="1" name="XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_FAR_META" comment="Indicates that the runtime will set the position and scale for far field keyboard."/> + <enum value="2" name="XR_VIRTUAL_KEYBOARD_LOCATION_TYPE_DIRECT_META" comment="Indicates that the runtime will set the position and scale for direct interaction keyboard."/> + </enums> + + <enums name="XrVirtualKeyboardInputSourceMETA" type="enum"> + <enum value="1" name="XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_RAY_LEFT_META" comment="Left controller ray."/> + <enum value="2" name="XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_RAY_RIGHT_META" comment="Right controller ray."/> + <enum value="3" name="XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_RAY_LEFT_META" comment="Left hand ray."/> + <enum value="4" name="XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_RAY_RIGHT_META" comment="Right hand ray."/> + <enum value="5" name="XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_DIRECT_LEFT_META" comment="Left controller direct touch."/> + <enum value="6" name="XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_CONTROLLER_DIRECT_RIGHT_META" comment="Right controller direct touch."/> + <enum value="7" name="XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_DIRECT_INDEX_TIP_LEFT_META" comment="Left hand direct touch."/> + <enum value="8" name="XR_VIRTUAL_KEYBOARD_INPUT_SOURCE_HAND_DIRECT_INDEX_TIP_RIGHT_META" comment="Right hand direct touch."/> + </enums> + + <enums name="XrVirtualKeyboardInputStateFlagBitsMETA" type="bitmask"> + <enum bitpos="0" name="XR_VIRTUAL_KEYBOARD_INPUT_STATE_PRESSED_BIT_META" comment="If the input source is considered 'pressed' at all. Pinch for hands, Primary button for controllers."/> + </enums> + + <!-- XR_ML_user_calibration --> + <enums name="XrHeadsetFitStatusML" type="enum"> + <enum value="0" name="XR_HEADSET_FIT_STATUS_UNKNOWN_ML" comment="Headset fit status not available for unknown reason."/> + <enum value="1" name="XR_HEADSET_FIT_STATUS_NOT_WORN_ML" comment="Headset not worn."/> + <enum value="2" name="XR_HEADSET_FIT_STATUS_GOOD_FIT_ML" comment="Good fit."/> + <enum value="3" name="XR_HEADSET_FIT_STATUS_BAD_FIT_ML" comment="Bad fit."/> + </enums> + + <enums name="XrEyeCalibrationStatusML" type="enum"> + <enum value="0" name="XR_EYE_CALIBRATION_STATUS_UNKNOWN_ML" comment="Eye calibration status not available for unknown reason."/> + <enum value="1" name="XR_EYE_CALIBRATION_STATUS_NONE_ML" comment="User has not performed the eye calibration step. Use system provided app to perform eye calibration."/> + <enum value="2" name="XR_EYE_CALIBRATION_STATUS_COARSE_ML" comment="Eye calibration is of lower accuracy."/> + <enum value="3" name="XR_EYE_CALIBRATION_STATUS_FINE_ML" comment="Eye calibration is of higher accuracy."/> + </enums> + + <!-- XR_ML_localization_map --> + <enums name="XrLocalizationMapStateML" type="enum"> + <enum value="0" name="XR_LOCALIZATION_MAP_STATE_NOT_LOCALIZED_ML" comment="The system is not localized into a map. Features like Spatial Anchors relying on localization will not work."/> + <enum value="1" name="XR_LOCALIZATION_MAP_STATE_LOCALIZED_ML" comment="The system is localized into a map."/> + <enum value="2" name="XR_LOCALIZATION_MAP_STATE_LOCALIZATION_PENDING_ML" comment="The system is localizing into a map."/> + <enum value="3" name="XR_LOCALIZATION_MAP_STATE_LOCALIZATION_SLEEPING_BEFORE_RETRY_ML" comment="Initial localization failed, the system will retry localization."/> + </enums> + + <enums name="XrLocalizationMapTypeML" type="enum"> + <enum value="0" name="XR_LOCALIZATION_MAP_TYPE_ON_DEVICE_ML" comment="The system is localized into an On-Device map, published anchors are not shared between different devices."/> + <enum value="1" name="XR_LOCALIZATION_MAP_TYPE_CLOUD_ML" comment="The system is localized into a Cloud Map, anchors are shared per cloud account settings."/> + </enums> + + <enums name="XrLocalizationMapConfidenceML" type="enum"> + <enum value="0" name="XR_LOCALIZATION_MAP_CONFIDENCE_POOR_ML" comment="The localization map has poor confidence, systems relying on the localization map are likely to have poor performance."/> + <enum value="1" name="XR_LOCALIZATION_MAP_CONFIDENCE_FAIR_ML" comment="The confidence is fair, current environmental conditions may adversely affect localization."/> + <enum value="2" name="XR_LOCALIZATION_MAP_CONFIDENCE_GOOD_ML" comment="The confidence is high, persistent content should be stable."/> + <enum value="3" name="XR_LOCALIZATION_MAP_CONFIDENCE_EXCELLENT_ML" comment="This is a very high-confidence localization, persistent content will be very stable."/> + </enums> + + <enums name="XrLocalizationMapErrorFlagBitsML" type="bitmask"> + <enum bitpos="0" name="XR_LOCALIZATION_MAP_ERROR_UNKNOWN_BIT_ML" comment="Localization failed for an unknown reason."/> + <enum bitpos="1" name="XR_LOCALIZATION_MAP_ERROR_OUT_OF_MAPPED_AREA_BIT_ML" comment="Localization failed because the user is outside of the mapped area."/> + <enum bitpos="2" name="XR_LOCALIZATION_MAP_ERROR_LOW_FEATURE_COUNT_BIT_ML" comment="There are not enough features in the environment to successfully localize."/> + <enum bitpos="3" name="XR_LOCALIZATION_MAP_ERROR_EXCESSIVE_MOTION_BIT_ML" comment="Localization failed due to excessive motion."/> + <enum bitpos="4" name="XR_LOCALIZATION_MAP_ERROR_LOW_LIGHT_BIT_ML" comment="Localization failed because the lighting levels are too low in the environment."/> + <enum bitpos="5" name="XR_LOCALIZATION_MAP_ERROR_HEADPOSE_BIT_ML" comment="A headpose failure caused localization to be unsuccessful."/> + </enums> + + <!-- XR_ML_facial_expression --> + <enums name="XrFacialBlendShapeML" type="enum" comment="Each facial blend shape describes an area/region of a face."> + <enum value="0" name="XR_FACIAL_BLEND_SHAPE_BROW_LOWERER_L_ML"/> + <enum value="1" name="XR_FACIAL_BLEND_SHAPE_BROW_LOWERER_R_ML"/> + <enum value="2" name="XR_FACIAL_BLEND_SHAPE_CHEEK_RAISER_L_ML"/> + <enum value="3" name="XR_FACIAL_BLEND_SHAPE_CHEEK_RAISER_R_ML"/> + <enum value="4" name="XR_FACIAL_BLEND_SHAPE_CHIN_RAISER_ML"/> + <enum value="5" name="XR_FACIAL_BLEND_SHAPE_DIMPLER_L_ML"/> + <enum value="6" name="XR_FACIAL_BLEND_SHAPE_DIMPLER_R_ML"/> + <enum value="7" name="XR_FACIAL_BLEND_SHAPE_EYES_CLOSED_L_ML"/> + <enum value="8" name="XR_FACIAL_BLEND_SHAPE_EYES_CLOSED_R_ML"/> + <enum value="9" name="XR_FACIAL_BLEND_SHAPE_INNER_BROW_RAISER_L_ML"/> + <enum value="10" name="XR_FACIAL_BLEND_SHAPE_INNER_BROW_RAISER_R_ML"/> + <enum value="11" name="XR_FACIAL_BLEND_SHAPE_JAW_DROP_ML"/> + <enum value="12" name="XR_FACIAL_BLEND_SHAPE_LID_TIGHTENER_L_ML"/> + <enum value="13" name="XR_FACIAL_BLEND_SHAPE_LID_TIGHTENER_R_ML"/> + <enum value="14" name="XR_FACIAL_BLEND_SHAPE_LIP_CORNER_DEPRESSOR_L_ML"/> + <enum value="15" name="XR_FACIAL_BLEND_SHAPE_LIP_CORNER_DEPRESSOR_R_ML"/> + <enum value="16" name="XR_FACIAL_BLEND_SHAPE_LIP_CORNER_PULLER_L_ML"/> + <enum value="17" name="XR_FACIAL_BLEND_SHAPE_LIP_CORNER_PULLER_R_ML"/> + <enum value="18" name="XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_LB_ML"/> + <enum value="19" name="XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_LT_ML"/> + <enum value="20" name="XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_RB_ML"/> + <enum value="21" name="XR_FACIAL_BLEND_SHAPE_LIP_FUNNELER_RT_ML"/> + <enum value="22" name="XR_FACIAL_BLEND_SHAPE_LIP_PRESSOR_L_ML"/> + <enum value="23" name="XR_FACIAL_BLEND_SHAPE_LIP_PRESSOR_R_ML"/> + <enum value="24" name="XR_FACIAL_BLEND_SHAPE_LIP_PUCKER_L_ML"/> + <enum value="25" name="XR_FACIAL_BLEND_SHAPE_LIP_PUCKER_R_ML"/> + <enum value="26" name="XR_FACIAL_BLEND_SHAPE_LIP_STRETCHER_L_ML"/> + <enum value="27" name="XR_FACIAL_BLEND_SHAPE_LIP_STRETCHER_R_ML"/> + <enum value="28" name="XR_FACIAL_BLEND_SHAPE_LIP_SUCK_LB_ML"/> + <enum value="29" name="XR_FACIAL_BLEND_SHAPE_LIP_SUCK_LT_ML"/> + <enum value="30" name="XR_FACIAL_BLEND_SHAPE_LIP_SUCK_RB_ML"/> + <enum value="31" name="XR_FACIAL_BLEND_SHAPE_LIP_SUCK_RT_ML"/> + <enum value="32" name="XR_FACIAL_BLEND_SHAPE_LIP_TIGHTENER_L_ML"/> + <enum value="33" name="XR_FACIAL_BLEND_SHAPE_LIP_TIGHTENER_R_ML"/> + <enum value="34" name="XR_FACIAL_BLEND_SHAPE_LIPS_TOWARD_ML"/> + <enum value="35" name="XR_FACIAL_BLEND_SHAPE_LOWER_LIP_DEPRESSOR_L_ML"/> + <enum value="36" name="XR_FACIAL_BLEND_SHAPE_LOWER_LIP_DEPRESSOR_R_ML"/> + <enum value="37" name="XR_FACIAL_BLEND_SHAPE_NOSE_WRINKLER_L_ML"/> + <enum value="38" name="XR_FACIAL_BLEND_SHAPE_NOSE_WRINKLER_R_ML"/> + <enum value="39" name="XR_FACIAL_BLEND_SHAPE_OUTER_BROW_RAISER_L_ML"/> + <enum value="40" name="XR_FACIAL_BLEND_SHAPE_OUTER_BROW_RAISER_R_ML"/> + <enum value="41" name="XR_FACIAL_BLEND_SHAPE_UPPER_LID_RAISER_L_ML"/> + <enum value="42" name="XR_FACIAL_BLEND_SHAPE_UPPER_LID_RAISER_R_ML"/> + <enum value="43" name="XR_FACIAL_BLEND_SHAPE_UPPER_LIP_RAISER_L_ML"/> + <enum value="44" name="XR_FACIAL_BLEND_SHAPE_UPPER_LIP_RAISER_R_ML"/> + <enum value="45" name="XR_FACIAL_BLEND_SHAPE_TONGUE_OUT_ML"/> + </enums> + + <enums name="XrFacialExpressionBlendShapePropertiesFlagBitsML" type="bitmask"> + <enum bitpos="0" name="XR_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_VALID_BIT_ML" comment="Indicates whether the blend shape is valid."/> + <enum bitpos="1" name="XR_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_TRACKED_BIT_ML" comment="Indicates whether the blend shape is being tracked by the runtime."/> + </enums> + + <!-- XR_EXT_future --> + <enums name="XrFutureStateEXT" type="enum"> + <enum value="1" name="XR_FUTURE_STATE_PENDING_EXT"/> + <enum value="2" name="XR_FUTURE_STATE_READY_EXT"/> + </enums> + + <!-- XR_META_environment_depth --> + <enums name="XrEnvironmentDepthProviderCreateFlagBitsMETA" type="bitmask"> + <!-- This is currently empty, awaiting future flags. --> + </enums> + <enums name="XrEnvironmentDepthSwapchainCreateFlagBitsMETA" type="bitmask"> + <!-- This is currently empty, awaiting future flags. --> + </enums> + + <!-- XR_ML_spatial_anchors --> + <enums name="XrSpatialAnchorConfidenceML" type="enum"> + <enum value="0" name="XR_SPATIAL_ANCHOR_CONFIDENCE_LOW_ML" comment="Low quality, this anchor can be expected to move significantly."/> + <enum value="1" name="XR_SPATIAL_ANCHOR_CONFIDENCE_MEDIUM_ML" comment="Medium quality, this anchor may move slightly."/> + <enum value="2" name="XR_SPATIAL_ANCHOR_CONFIDENCE_HIGH_ML" comment="High quality, this anchor is stable and suitable for digital content attachment."/> + </enums> + + <!-- XR_BD_spatial_audio_rendering --> + <enums name="XrAudioSampleRateBD" type="enum"> + <enum value="1" name="XR_AUDIO_SAMPLE_RATE_192000_HZ_BD" comment="192000 Hz"/> + <enum value="2" name="XR_AUDIO_SAMPLE_RATE_96000_HZ_BD" comment="96000 Hz"/> + <enum value="3" name="XR_AUDIO_SAMPLE_RATE_48000_HZ_BD" comment="48000 Hz"/> + <enum value="4" name="XR_AUDIO_SAMPLE_RATE_44100_HZ_BD" comment="44100 Hz"/> + <enum value="5" name="XR_AUDIO_SAMPLE_RATE_32000_HZ_BD" comment="32000 Hz"/> + <enum value="6" name="XR_AUDIO_SAMPLE_RATE_24000_HZ_BD" comment="24000 Hz"/> + <enum value="7" name="XR_AUDIO_SAMPLE_RATE_22050_HZ_BD" comment="22050 Hz"/> + <enum value="8" name="XR_AUDIO_SAMPLE_RATE_16000_HZ_BD" comment="16000 Hz"/> + <enum value="9" name="XR_AUDIO_SAMPLE_RATE_12000_HZ_BD" comment="12000 Hz"/> + <enum value="10" name="XR_AUDIO_SAMPLE_RATE_11025_HZ_BD" comment="11025 Hz"/> + <enum value="11" name="XR_AUDIO_SAMPLE_RATE_8000_HZ_BD" comment="8000 Hz"/> + </enums> + + <enums name="XrAudioBufferChannelLayoutBD" type="enum"> + <enum value="0" name="XR_AUDIO_BUFFER_CHANNEL_LAYOUT_INTERLEAVED_BD" comment="indicates that audio samples from all channels are stored in an interleaved layout, where successive frames contain one sample per channel (e.g. LRLRLR for stereo)"/> + <enum value="1" name="XR_AUDIO_BUFFER_CHANNEL_LAYOUT_PLANAR_BD" comment="indicates that audio samples are stored in a planar layout, where all samples for one channel are contiguous in memory (e.g. LLL...RRR... for stereo)"/> + </enums> + + <enums name="XrSoundObstacleMaterialTypeBD" type="enum"> + <enum value="0" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_ACOUSTIC_TILE_BD" comment="indicates that the material is acoustic tile"/> + <enum value="1" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_BRICK_BD" comment="indicates that the material resembles brick"/> + <enum value="2" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_BRICK_PAINTED_BD" comment="indicates that the material resembles painted brick"/> + <enum value="3" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_CARPET_BD" comment="indicates that the material resembles carpet"/> + <enum value="4" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_CARPET_HEAVY_BD" comment="indicates that the material resembles heavy carpet"/> + <enum value="5" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_CARPET_HEAVY_PADDED_BD" comment="indicates that the material resembles heavily padded carpet"/> + <enum value="6" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_CERAMIC_TILE_BD" comment="indicates that the material resembles ceramic tile"/> + <enum value="7" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_BD" comment="indicates that the material resembles concrete"/> + <enum value="8" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_ROUGH_BD" comment="indicates that the material resembles rough concrete"/> + <enum value="9" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_BLOCK_BD" comment="indicates that the material resembles concrete block"/> + <enum value="10" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_CONCRETE_BLOCK_PAINTED_BD" comment="indicates that the material resembles painted concrete block"/> + <enum value="11" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_CURTAIN_BD" comment="indicates that the material resembles curtain"/> + <enum value="12" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_FOLIAGE_BD" comment="indicates that the material resembles foliage"/> + <enum value="13" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_GLASS_BD" comment="indicates that the material resembles glass"/> + <enum value="14" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_GLASS_HEAVY_BD" comment="indicates that the material resembles heavy glass"/> + <enum value="15" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_GRASS_BD" comment="indicates that the material resembles grass"/> + <enum value="16" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_GRAVEL_BD" comment="indicates that the material resembles gravel"/> + <enum value="17" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_GYPSUM_BOARD_BD" comment="indicates that the material resembles gypsum board"/> + <enum value="18" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_PLASTER_ON_BRICK_BD" comment="indicates that the material resembles plaster on brick"/> + <enum value="19" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_PLASTER_ON_CONCRETE_BLOCK_BD" comment="indicates that the material resembles plaster on concrete block"/> + <enum value="20" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_SOIL_BD" comment="indicates that the material resembles soil"/> + <enum value="21" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_SOUND_PROOF_BD" comment="indicates that the material resembles sound proof"/> + <enum value="22" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_SNOW_BD" comment="indicates that the material resembles snow"/> + <enum value="23" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_STEEL_BD" comment="indicates that the material resembles steel"/> + <enum value="24" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_WATER_BD" comment="indicates that the material resembles water"/> + <enum value="25" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_THIN_BD" comment="indicates that the material resembles thin wood"/> + <enum value="26" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_THICK_BD" comment="indicates that the material resembles thick wood"/> + <enum value="27" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_FLOOR_BD" comment="indicates that the material resembles floor"/> + <enum value="28" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_WOOD_ON_CONCRETE_BD" comment="indicates that the material resembles wood on concrete"/> + <enum value="29" name="XR_SOUND_OBSTACLE_MATERIAL_TYPE_CUSTOM_BD" comment="Customized material described by detailed acoustic surface parameters, for example, absorption, scattering, and transmission."/> + </enums> + + <enums name="XrSoundObjectDistanceAttenuationTypeBD" type="enum"> + <enum value="0" name="XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_NONE_BD" comment="Indicates that no attenuation is applied when source-listener distance varies."/> + <enum value="1" name="XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_INVERSE_SQUARE_BD" comment="Indicates that attenuation scales proportional to the inverse-squared distance of source-listener distance."/> + <enum value="2" name="XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_ROLLOFF_BD" comment="Indicates that attenuation equals pow(distance/refer_distance, -rolloff_factor), in which distance is clamped by minAttenuationRange and maxAttenuationRange."/> + <enum value="100" name="XR_SOUND_OBJECT_DISTANCE_ATTENUATION_TYPE_CUSTOMIZED_BD" comment="Indicates that the distance attenuation is customized."/> + </enums> + + <enums name="XrSoundFieldChannelMaskSurroundBD" type="enum"> + <enum value="1" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_LEFT_BD" comment="Bitmask of ear-level front-left speaker"/> + <enum value="2" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_RIGHT_BD" comment="Bitmask of ear-level front-right speaker"/> + <enum value="4" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_CENTER_BD" comment="Bitmask of ear-level front-center speaker"/> + <enum value="8" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_LOW_FREQUENCY_BD" comment="Bitmask of LFE speaker"/> + <enum value="16" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_LEFT_BD" comment="Bitmask of ear-level back-left speaker"/> + <enum value="32" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_RIGHT_BD" comment="Bitmask of ear-level back-right speaker"/> + <enum value="64" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SIDE_LEFT_BD" comment="Bitmask of ear-level side-left speaker"/> + <enum value="128" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SIDE_RIGHT_BD" comment="Bitmask of ear-level side-right speaker"/> + <enum value="256" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_LEFT_BD" comment="Bitmask of height-channel front-left speaker"/> + <enum value="512" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_RIGHT_BD" comment="Bitmask of height-channel front-right speaker"/> + <enum value="1024" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_BACK_LEFT_BD" comment="Bitmask of height-channel back-left speaker"/> + <enum value="2048" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_BACK_RIGHT_BD" comment="Bitmask of height-channel back-right speaker"/> + <enum value="4096" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_CENTER_BD" comment="Bitmask of ear-level back-center speaker"/> + <enum value="8192" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_SIDE_LEFT_BD" comment="Bitmask of height-channel side-left speaker"/> + <enum value="16384" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_SIDE_RIGHT_BD" comment="Bitmask of height-channel side-right speaker"/> + <enum value="3" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_STEREO_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_LEFT_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_RIGHT_BD"/> + <enum value="11" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_2_1_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_STEREO_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_LOW_FREQUENCY_BD"/> + <enum value="7" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_3_0_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_STEREO_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_FRONT_CENTER_BD"/> + <enum value="4099" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_4_0_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_3_0_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_CENTER_BD"/> + <enum value="48" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_BACK_SURROUND_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_LEFT_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_BACK_RIGHT_BD"/> + <enum value="51" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_QUAD_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_STEREO_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_BACK_SURROUND_BD"/> + <enum value="15" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_3_1_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_3_0_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_LOW_FREQUENCY_BD"/> + <enum value="55" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_0_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_3_0_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_BACK_SURROUND_BD"/> + <enum value="192" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_SIDE_SURROUND_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SIDE_LEFT_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SIDE_RIGHT_BD"/> + <enum value="199" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_0_SIDE_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_3_0_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_SIDE_SURROUND_BD"/> + <enum value="63" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_0_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_LOW_FREQUENCY_BD"/> + <enum value="207" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_SIDE_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_SIDE_SURROUND_BD"/> + <enum value="247" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_0_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_0_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_SIDE_SURROUND_BD"/> + <enum value="255" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_1_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_0_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_LOW_FREQUENCY_BD"/> + <enum value="831" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_2_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_LEFT_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_RIGHT_BD"/> + <enum value="3903" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_4_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_5_1_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_LEFT_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_RIGHT_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_BACK_LEFT_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_BACK_RIGHT_BD"/> + <enum value="24831" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_1_2_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_1_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_SIDE_LEFT_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_SIDE_RIGHT_BD"/> + <enum value="4095" name="XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_1_4_BD" comment="Composition of ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_SETUP_7_1_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_LEFT_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_FRONT_RIGHT_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_BACK_LEFT_BD and ename:XR_SOUND_FIELD_CHANNEL_MASK_SURROUND_TOP_BACK_RIGHT_BD"/> + </enums> + + <enums name="XrSoundFieldChannelMaskAmbixBD" type="enum"> + <enum value="1" name="XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_1ST_ORDER_BD" comment="Indicates 1st-order ambisonics in AmbiX format, which uses ACN (Ambisonic Channel Number) channel ordering and SN3D normalization"/> + <enum value="2" name="XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_2ND_ORDER_BD" comment="Indicates 2nd-order ambisonics in AmbiX format, which uses ACN (Ambisonic Channel Number) channel ordering and SN3D normalization"/> + <enum value="3" name="XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_3RD_ORDER_BD" comment="Indicates 3rd-order ambisonics in AmbiX format, which uses ACN (Ambisonic Channel Number) channel ordering and SN3D normalization"/> + <enum value="4" name="XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_4TH_ORDER_BD" comment="Indicates 4th-order ambisonics in AmbiX format, which uses ACN (Ambisonic Channel Number) channel ordering and SN3D normalization"/> + <enum value="5" name="XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_5TH_ORDER_BD" comment="Indicates 5th-order-ambisonics in AmbiX format, which uses ACN (Ambisonic Channel Number) channel ordering and SN3D normalization"/> + <enum value="6" name="XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_6TH_ORDER_BD" comment="Indicates 6th-order ambisonics in AmbiX format, which uses ACN (Ambisonic Channel Number) channel ordering and SN3D normalization"/> + <enum value="7" name="XR_SOUND_FIELD_CHANNEL_MASK_AMBIX_7TH_ORDER_BD" comment="Indicates 7th-order ambisonics in AmbiX format, which uses ACN (Ambisonic Channel Number) channel ordering and SN3D normalization"/> + </enums> + + <enums name="XrSoundFieldChannelMaskFumaBD" type="enum"> + <enum value="1" name="XR_SOUND_FIELD_CHANNEL_MASK_FUMA_1ST_ORDER_BD" comment="Indicates the 1st-order ambisonic in FuMA format, which refers to Furse-Malham channel order and maxN normalization"/> + </enums> + + <enums name="XrSoundObstacleFlagBitsBD" type="bitmask"> + <enum bitpos="0" name="XR_SOUND_OBSTACLE_ENABLED_BIT_BD" comment="to indicate an update of slink:XrSoundObstacleConfigBD::pname:enabled"/> + <enum bitpos="1" name="XR_SOUND_OBSTACLE_POSE_BIT_BD" comment="to indicate an update of slink:XrSoundObstacleConfigBD::pname:pose"/> + <enum bitpos="2" name="XR_SOUND_OBSTACLE_MESH_BIT_BD" comment="to indicate an update of slink:XrSoundObstacleConfigBD::pname:mesh"/> + <enum bitpos="3" name="XR_SOUND_OBSTACLE_MATERIALS_BIT_BD" comment="to indicate an update of slink:XrSoundObstacleConfigBD::pname:materials"/> + </enums> + + <enums name="XrSoundObjectFlagBitsBD" type="bitmask"> + <enum bitpos="0" name="XR_SOUND_OBJECT_ENABLED_BIT_BD" comment="to indicate an update of slink:XrSoundObjectConfigBD::pname:enabled"/> + <enum bitpos="1" name="XR_SOUND_OBJECT_POSE_BIT_BD" comment="to indicate an update of slink:XrSoundObjectConfigBD::pname:pose"/> + <enum bitpos="2" name="XR_SOUND_OBJECT_DIRECTIVITY_BIT_BD" comment="to indicate an update of the directivity using an slink:XrSoundObjectDirectivityCardioidBD chained to slink:XrSoundObjectConfigBD::pname:next"/> + <enum bitpos="3" name="XR_SOUND_OBJECT_SHAPE_BIT_BD" comment="to indicate an update of the shape using an slink:XrSoundObjectShapeSphereBD chained to slink:XrSoundObjectConfigBD::pname:next"/> + <enum bitpos="4" name="XR_SOUND_OBJECT_MAIN_VOLUME_BIT_BD" comment="to indicate an update of slink:XrSoundObjectConfigBD::pname:mainVolume"/> + <enum bitpos="5" name="XR_SOUND_OBJECT_REFLECTION_GAIN_BIT_BD" comment="to indicate an update of slink:XrSoundObjectConfigBD::pname:reflectionGain"/> + <enum bitpos="6" name="XR_SOUND_OBJECT_ENABLE_DOPPLER_BIT_BD" comment="to indicate an update of slink:XrSoundObjectConfigBD::pname:enableDoppler"/> + <enum bitpos="7" name="XR_SOUND_OBJECT_DIRECT_SOUND_ATTENUATION_BIT_BD" comment="to indicate an update of slink:XrSoundObjectConfigBD::pname:directSoundAttenuation"/> + <enum bitpos="8" name="XR_SOUND_OBJECT_INDIRECT_SOUND_ATTENUATION_BIT_BD" comment="to indicate an update of slink:XrSoundObjectConfigBD::pname:indirectSoundAttenuation"/> + </enums> + + <enums name="XrSoundFieldFlagBitsBD" type="bitmask"> + <enum bitpos="0" name="XR_SOUND_FIELD_ENABLED_BIT_BD" comment="to indicate an update of slink:XrSoundFieldConfigBD::pname:enabled"/> + <enum bitpos="1" name="XR_SOUND_FIELD_ORIENTATION_BIT_BD" comment="to indicate an update of slink:XrSoundFieldConfigBD::pname:pose and/or slink:XrSoundFieldConfigBD::pname:baseSpace"/> + <enum bitpos="2" name="XR_SOUND_FIELD_MAIN_VOLUME_BIT_BD" comment="to indicate an update of slink:XrSoundFieldConfigBD::pname:mainVolume"/> + <enum bitpos="3" name="XR_SOUND_FIELD_LFE_GAIN_BIT_BD" comment="to indicate an update of slink:XrSoundFieldConfigBD::pname:lfeGain"/> + </enums> + + <!-- enums for XR_BD_spatial_sensing --> + <enums name="XrSenseDataProviderTypeBD" type="enum"> + <!-- contents from other extensions --> + </enums> + + <!-- enums for XR_BD_dynamic_object_tracking --> + <enums name="XrDynamicObjectTypeBD" type="enum"> + <enum value="0" name="XR_DYNAMIC_OBJECT_TYPE_UNKNOWN_BD" comment="Represents an unknown object type."/> + </enums> + + <enums name="XrSemanticLabelBD" type="enum"> + <enum value="0" name="XR_SEMANTIC_LABEL_UNKNOWN_BD" comment="Semantic label that the runtime does not know."/> + <enum value="1" name="XR_SEMANTIC_LABEL_FLOOR_BD" comment="Semantic label of floor."/> + <enum value="2" name="XR_SEMANTIC_LABEL_CEILING_BD" comment="Semantic label of ceiling."/> + <enum value="3" name="XR_SEMANTIC_LABEL_WALL_BD" comment="Semantic label of wall."/> + <enum value="4" name="XR_SEMANTIC_LABEL_DOOR_BD" comment="Semantic label of door."/> + <enum value="5" name="XR_SEMANTIC_LABEL_WINDOW_BD" comment="Semantic label of window."/> + <enum value="6" name="XR_SEMANTIC_LABEL_OPENING_BD" comment="Semantic label of opening, usually refers to a space that something or someone can pass through."/> + <enum value="7" name="XR_SEMANTIC_LABEL_TABLE_BD" comment="Semantic label of table."/> + <enum value="8" name="XR_SEMANTIC_LABEL_SOFA_BD" comment="Semantic label of sofa, usually refers to a seat that multiple people can sit on."/> + <enum value="9" name="XR_SEMANTIC_LABEL_CHAIR_BD" comment="Semantic label of chair, usually refers to a seat that for one person."/> + <enum value="10" name="XR_SEMANTIC_LABEL_HUMAN_BD" comment="Semantic label of human."/> + <enum value="11" name="XR_SEMANTIC_LABEL_BEAM_BD" comment="Semantic label of beam, which usually supports weight in a building or other structure."/> + <enum value="12" name="XR_SEMANTIC_LABEL_COLUMN_BD" comment="Semantic label of column, which is vertical and used as a support for the roof of a building."/> + <enum value="13" name="XR_SEMANTIC_LABEL_CURTAIN_BD" comment="Semantic label of curtain."/> + <enum value="14" name="XR_SEMANTIC_LABEL_CABINET_BD" comment="Semantic label of cabinet."/> + <enum value="15" name="XR_SEMANTIC_LABEL_BED_BD" comment="Semantic label of bed."/> + <enum value="16" name="XR_SEMANTIC_LABEL_PLANT_BD" comment="Semantic label of plant."/> + <enum value="17" name="XR_SEMANTIC_LABEL_SCREEN_BD" comment="Semantic label of screen."/> + <enum value="18" name="XR_SEMANTIC_LABEL_VIRTUAL_WALL_BD" comment="Semantic label of virtual wall, which is generated by the system scene capture app in order to create a closed space for users."/> + <enum value="19" name="XR_SEMANTIC_LABEL_REFRIGERATOR_BD" comment="Semantic label of refrigerator."/> + <enum value="20" name="XR_SEMANTIC_LABEL_WASHING_MACHINE_BD" comment="Semantic label of washing machine."/> + <enum value="21" name="XR_SEMANTIC_LABEL_AIR_CONDITIONER_BD" comment="Semantic label of air conditioner."/> + <enum value="22" name="XR_SEMANTIC_LABEL_LAMP_BD" comment="Semantic label of lamp."/> + <enum value="23" name="XR_SEMANTIC_LABEL_WALL_ART_BD" comment="Semantic label of wall art, like a painting or a photo frame."/> + <enum value="24" name="XR_SEMANTIC_LABEL_STAIRWAY_BD" comment="Semantic label of stairway."/> + <enum value="25" name="XR_SEMANTIC_LABEL_KEYBOARD_BD" comment="Semantic label of keyboard, added in extension revision 3."/> + <enum value="26" name="XR_SEMANTIC_LABEL_MOUSE_BD" comment="Semantic label of mouse, added in extension revision 3."/> + <enum value="27" name="XR_SEMANTIC_LABEL_LAPTOP_BD" comment="Semantic label of laptop, added in extension revision 3."/> + </enums> + + <enums name="XrSpatialEntityComponentTypeBD" type="enum"> + <enum value="0" name="XR_SPATIAL_ENTITY_COMPONENT_TYPE_LOCATION_BD" comment="The location including position and rotation. Corresponds to component data structure slink:XrSpatialEntityComponentDataLocationBD."/> + <enum value="1" name="XR_SPATIAL_ENTITY_COMPONENT_TYPE_SEMANTIC_BD" comment="The semantic label. Corresponds to component data structure slink:XrSpatialEntityComponentDataSemanticBD."/> + <enum value="2" name="XR_SPATIAL_ENTITY_COMPONENT_TYPE_BOUNDING_BOX_2D_BD" comment="The two-dimensional bounding box. Corresponds to component data structure slink:XrSpatialEntityComponentDataBoundingBox2DBD."/> + <enum value="3" name="XR_SPATIAL_ENTITY_COMPONENT_TYPE_POLYGON_BD" comment="The two-dimensional polygon. Corresponds to component data structure slink:XrSpatialEntityComponentDataPolygonBD."/> + <enum value="4" name="XR_SPATIAL_ENTITY_COMPONENT_TYPE_BOUNDING_BOX_3D_BD" comment="The three-dimensional bounding box. Corresponds to component data structure slink:XrSpatialEntityComponentDataBoundingBox3DBD."/> + <enum value="5" name="XR_SPATIAL_ENTITY_COMPONENT_TYPE_TRIANGLE_MESH_BD" comment="The triangle mesh. Corresponds to component data structure slink:XrSpatialEntityComponentDataTriangleMeshBD."/> + <enum value="6" name="XR_SPATIAL_ENTITY_COMPONENT_TYPE_SPHERE_BD" comment="The Sphere. Corresponds to component data structure slink:XrSpatialEntityComponentDataSphereBD."/> + </enums> + + <enums name="XrSenseDataProviderStateBD" type="enum"> + <enum value="0" name="XR_SENSE_DATA_PROVIDER_STATE_INITIALIZED_BD" comment="The state after the provider is successfully created, which means the provider is ready to start."/> + <enum value="1" name="XR_SENSE_DATA_PROVIDER_STATE_RUNNING_BD" comment="The state when the provider is running normally."/> + <enum value="2" name="XR_SENSE_DATA_PROVIDER_STATE_STOPPED_BD" comment="The state after the provider is successfully stopped, or when an unexpected error occurs."/> + </enums> + + <!-- enums for XR_BD_spatial_anchor --> + <enums name="XrPersistenceLocationBD" type="enum"> + <enum value="0" name="XR_PERSISTENCE_LOCATION_LOCAL_BD" comment="The persistence storage location is local to the device."/> + </enums> + + <!-- enums for XR_BD_spatial_mesh --> + <enums name="XrSpatialMeshLodBD" type="enum"> + <enum value="0" name="XR_SPATIAL_MESH_LOD_COARSE_BD" comment="Coarse level for the mesh with less details."/> + <enum value="1" name="XR_SPATIAL_MESH_LOD_MEDIUM_BD" comment="Medium level for the mesh."/> + <enum value="2" name="XR_SPATIAL_MESH_LOD_FINE_BD" comment="Fine level for the mesh with more details."/> + </enums> + + <enums name="XrSpatialMeshConfigFlagBitsBD" type="bitmask"> + <enum bitpos="0" name="XR_SPATIAL_MESH_CONFIG_SEMANTIC_BIT_BD" comment="Detect and include semantic label component data in the spatial entity."/> + <enum bitpos="1" name="XR_SPATIAL_MESH_CONFIG_ALIGN_SEMANTIC_WITH_VERTEX_BIT_BD" comment="Semantic labels are associated with each vertex, otherwise, semantic labels are associated with each triangle face by default. It only takes effect if ename:XR_SPATIAL_MESH_CONFIG_SEMANTIC_BIT_BD is set"/> + </enums> + + <!-- enums for XR_BD_spatial_plane --> + <enums name="XrPlaneOrientationBD" type="enum"> + <enum value="0" name="XR_PLANE_ORIENTATION_HORIZONTAL_UPWARD_BD" comment="The detected plane is horizontal and faces upward (e.g. floor)."/> + <enum value="1" name="XR_PLANE_ORIENTATION_HORIZONTAL_DOWNWARD_BD" comment="The detected plane is horizontal and faces downward (e.g. ceiling)."/> + <enum value="2" name="XR_PLANE_ORIENTATION_VERTICAL_BD" comment="The detected plane is vertical (e.g. wall)."/> + <enum value="3" name="XR_PLANE_ORIENTATION_ARBITRARY_BD" comment="The detected plane has an arbitrary, non-vertical and non-horizontal orientation."/> + </enums> + + <!-- XR_EXT_spatial_entity --> + <enums name="XrSpatialComponentTypeEXT" type="enum"> + <enum value="1" name="XR_SPATIAL_COMPONENT_TYPE_BOUNDED_2D_EXT" comment="Component that provides the 2D bounds for a spatial entity. Corresponding list structure is slink:XrSpatialComponentBounded2DListEXT; Corresponding data structure is slink:XrSpatialBounded2DDataEXT"/> + <enum value="2" name="XR_SPATIAL_COMPONENT_TYPE_BOUNDED_3D_EXT" comment="Component that provides the 3D bounds for a spatial entity. Corresponding list structure is slink:XrSpatialComponentBounded3DListEXT; Corresponding data structure is slink:XrBoxf"/> + <enum value="3" name="XR_SPATIAL_COMPONENT_TYPE_PARENT_EXT" comment="Component that provides the basetype:XrSpatialEntityIdEXT of the parent for a spatial entity. Corresponding list structure is slink:XrSpatialComponentParentListEXT; Corresponding data structure is basetype:XrSpatialEntityIdEXT"/> + <enum value="4" name="XR_SPATIAL_COMPONENT_TYPE_MESH_3D_EXT" comment="Component that provides a 3D mesh for a spatial entity. Corresponding list structure is slink:XrSpatialComponentMesh3DListEXT; Corresponding data structure is slink:XrSpatialMeshDataEXT"/> + </enums> + + <enums name="XrSpatialEntityTrackingStateEXT" type="enum"> + <enum value="1" name="XR_SPATIAL_ENTITY_TRACKING_STATE_STOPPED_EXT" comment="The runtime has stopped tracking this entity and will never resume tracking it."/> + <enum value="2" name="XR_SPATIAL_ENTITY_TRACKING_STATE_PAUSED_EXT" comment="The runtime has paused tracking this entity but may: resume tracking it in the future."/> + <enum value="3" name="XR_SPATIAL_ENTITY_TRACKING_STATE_TRACKING_EXT" comment="The runtime is currently tracking this entity and its component data is valid."/> + </enums> + + <enums name="XrSpatialCapabilityEXT" type="enum"> + </enums> + + <enums name="XrSpatialCapabilityFeatureEXT" type="enum"> + </enums> + + <enums name="XrSpatialBufferTypeEXT" type="enum"> + <enum value="0" name="XR_SPATIAL_BUFFER_TYPE_UNKNOWN_EXT"/> + <enum value="1" name="XR_SPATIAL_BUFFER_TYPE_STRING_EXT"/> + <enum value="2" name="XR_SPATIAL_BUFFER_TYPE_UINT8_EXT"/> + <enum value="3" name="XR_SPATIAL_BUFFER_TYPE_UINT16_EXT"/> + <enum value="4" name="XR_SPATIAL_BUFFER_TYPE_UINT32_EXT"/> + <enum value="5" name="XR_SPATIAL_BUFFER_TYPE_FLOAT_EXT"/> + <enum value="6" name="XR_SPATIAL_BUFFER_TYPE_VECTOR2F_EXT"/> + <enum value="7" name="XR_SPATIAL_BUFFER_TYPE_VECTOR3F_EXT"/> + </enums> + + <!-- XR_EXT_spatial_persistence --> + <enums name="XrSpatialPersistenceScopeEXT" type="enum"> + <enum value="1" name="XR_SPATIAL_PERSISTENCE_SCOPE_SYSTEM_MANAGED_EXT" comment="Provides the application with read-only access (i.e. application cannot modify the store associated with this scope) to spatial entities persisted and managed by the system. The application can: use the UUID in the persistence component for this scope to correlate entities across spatial contexts and device reboots."/> + </enums> + + <enums name="XrSpatialPersistenceContextResultEXT" type="enum"> + <!-- Return codes for successful operation execution (positive values) --> + <enum value="0" name="XR_SPATIAL_PERSISTENCE_CONTEXT_RESULT_SUCCESS_EXT" comment="The persistence context operation was a success."/> + <!-- Error codes (negative values) --> + </enums> + + <enums name="XrSpatialPersistenceStateEXT" type="enum"> + <enum value="1" name="XR_SPATIAL_PERSISTENCE_STATE_LOADED_EXT" comment="The persisted UUID has been successfully loaded from the storage."/> + <enum value="2" name="XR_SPATIAL_PERSISTENCE_STATE_NOT_FOUND_EXT" comment="The persisted UUID was not found in the storage and was either removed from it or never was in it."/> + </enums> + + <!-- XR_EXT_spatial_plane_tracking --> + <enums name="XrSpatialPlaneAlignmentEXT" type="enum"> + <enum value="0" name="XR_SPATIAL_PLANE_ALIGNMENT_HORIZONTAL_UPWARD_EXT" comment="The entity is horizontal and faces upward (e.g. floor)."/> + <enum value="1" name="XR_SPATIAL_PLANE_ALIGNMENT_HORIZONTAL_DOWNWARD_EXT" comment="The entity is horizontal and faces downward (e.g. ceiling)."/> + <enum value="2" name="XR_SPATIAL_PLANE_ALIGNMENT_VERTICAL_EXT" comment="The entity is vertical (e.g. wall)."/> + <enum value="3" name="XR_SPATIAL_PLANE_ALIGNMENT_ARBITRARY_EXT" comment="The entity has an arbitrary, non-vertical and non-horizontal orientation."/> + </enums> + + <enums name="XrSpatialPlaneSemanticLabelEXT" type="enum"> + <enum value="1" name="XR_SPATIAL_PLANE_SEMANTIC_LABEL_UNCATEGORIZED_EXT" comment="The runtime was unable to classify this entity."/> + <enum value="2" name="XR_SPATIAL_PLANE_SEMANTIC_LABEL_FLOOR_EXT" comment="The entity is a floor."/> + <enum value="3" name="XR_SPATIAL_PLANE_SEMANTIC_LABEL_WALL_EXT" comment="The entity is a wall."/> + <enum value="4" name="XR_SPATIAL_PLANE_SEMANTIC_LABEL_CEILING_EXT" comment="The entity is a ceiling."/> + <enum value="5" name="XR_SPATIAL_PLANE_SEMANTIC_LABEL_TABLE_EXT" comment="The entity is a table."/> + </enums> + + <!-- XR_EXT_spatial_marker_tracking --> + <enums name="XrSpatialMarkerArucoDictEXT" type="enum"> + <enum value="1" name="XR_SPATIAL_MARKER_ARUCO_DICT_4X4_50_EXT" comment="4 by 4 pixel Aruco marker dictionary with 50 IDs."/> + <enum value="2" name="XR_SPATIAL_MARKER_ARUCO_DICT_4X4_100_EXT" comment="4 by 4 pixel Aruco marker dictionary with 100 IDs."/> + <enum value="3" name="XR_SPATIAL_MARKER_ARUCO_DICT_4X4_250_EXT" comment="4 by 4 pixel Aruco marker dictionary with 250 IDs."/> + <enum value="4" name="XR_SPATIAL_MARKER_ARUCO_DICT_4X4_1000_EXT" comment="4 by 4 pixel Aruco marker dictionary with 1000 IDs."/> + <enum value="5" name="XR_SPATIAL_MARKER_ARUCO_DICT_5X5_50_EXT" comment="5 by 5 pixel Aruco marker dictionary with 50 IDs."/> + <enum value="6" name="XR_SPATIAL_MARKER_ARUCO_DICT_5X5_100_EXT" comment="5 by 5 pixel Aruco marker dictionary with 100 IDs."/> + <enum value="7" name="XR_SPATIAL_MARKER_ARUCO_DICT_5X5_250_EXT" comment="5 by 5 pixel Aruco marker dictionary with 250 IDs."/> + <enum value="8" name="XR_SPATIAL_MARKER_ARUCO_DICT_5X5_1000_EXT" comment="5 by 5 pixel Aruco marker dictionary with 1000 IDs."/> + <enum value="9" name="XR_SPATIAL_MARKER_ARUCO_DICT_6X6_50_EXT" comment="6 by 6 pixel Aruco marker dictionary with 50 IDs."/> + <enum value="10" name="XR_SPATIAL_MARKER_ARUCO_DICT_6X6_100_EXT" comment="6 by 6 pixel Aruco marker dictionary with 100 IDs."/> + <enum value="11" name="XR_SPATIAL_MARKER_ARUCO_DICT_6X6_250_EXT" comment="6 by 6 pixel Aruco marker dictionary with 250 IDs."/> + <enum value="12" name="XR_SPATIAL_MARKER_ARUCO_DICT_6X6_1000_EXT" comment="6 by 6 pixel Aruco marker dictionary with 1000 IDs."/> + <enum value="13" name="XR_SPATIAL_MARKER_ARUCO_DICT_7X7_50_EXT" comment="7 by 7 pixel Aruco marker dictionary with 50 IDs."/> + <enum value="14" name="XR_SPATIAL_MARKER_ARUCO_DICT_7X7_100_EXT" comment="7 by 7 pixel Aruco marker dictionary with 100 IDs."/> + <enum value="15" name="XR_SPATIAL_MARKER_ARUCO_DICT_7X7_250_EXT" comment="7 by 7 pixel Aruco marker dictionary with 250 IDs."/> + <enum value="16" name="XR_SPATIAL_MARKER_ARUCO_DICT_7X7_1000_EXT" comment="7 by 7 pixel Aruco marker dictionary with 1000 IDs."/> + </enums> + + <enums name="XrSpatialMarkerAprilTagDictEXT" type="enum"> + <enum value="1" name="XR_SPATIAL_MARKER_APRIL_TAG_DICT_16H5_EXT" comment="4 by 4 bits, minimum Hamming distance between any two codes = 5, 30 codes."/> + <enum value="2" name="XR_SPATIAL_MARKER_APRIL_TAG_DICT_25H9_EXT" comment="5 by 5 bits, minimum Hamming distance between any two codes = 9, 35 codes."/> + <enum value="3" name="XR_SPATIAL_MARKER_APRIL_TAG_DICT_36H10_EXT" comment="6 by 6 bits, minimum Hamming distance between any two codes = 10, 2320 codes."/> + <enum value="4" name="XR_SPATIAL_MARKER_APRIL_TAG_DICT_36H11_EXT" comment="6 by 6 bits, minimum Hamming distance between any two codes = 11, 587 codes."/> + </enums> + + <!-- enums for XR_BD_spatial_light_estimation --> + <enums name="XrLightEstimationCreateFlagBitsBD" type="bitmask"> + <enum bitpos="0" name="XR_LIGHT_ESTIMATION_CREATE_SPHERICAL_HARMONICS_BIT_BD" comment="Enables spherical harmonics coefficients for light estimate provider"/> + <enum bitpos="1" name="XR_LIGHT_ESTIMATION_CREATE_ENVIRONMENT_TEXTURE_BIT_BD" comment="Enables environment textures for light estimate provider"/> + </enums> + + <enums name="XrEnvironmentTextureResolutionBD" type="enum"> + <enum value="0" name="XR_ENVIRONMENT_TEXTURE_RESOLUTION_8_8_BD" comment="Environment Texture resolution of 8x8 pixels for configuring the light estimation provider."/> + <enum value="1" name="XR_ENVIRONMENT_TEXTURE_RESOLUTION_16_16_BD" comment="Environment Texture resolution of 16x16 pixels for configuring the light estimation provider."/> + <enum value="2" name="XR_ENVIRONMENT_TEXTURE_RESOLUTION_32_32_BD" comment="Environment Texture resolution of 32x32 pixels for configuring the light estimation provider."/> + <enum value="3" name="XR_ENVIRONMENT_TEXTURE_RESOLUTION_64_64_BD" comment="Environment Texture resolution of 64x64 pixels for configuring the light estimation provider."/> + <enum value="4" name="XR_ENVIRONMENT_TEXTURE_RESOLUTION_128_128_BD" comment="Environment Texture resolution of 128x128 pixels for configuring the light estimation provider."/> + </enums> + + <enums name="XrEnvironmentTextureTransferTypeBD" type="enum"> + <enum value="0" name="XR_ENVIRONMENT_TEXTURE_TRANSFER_TYPE_RAW_BD" comment="Environment Texture data transferred as raw memory buffer."/> + </enums> + + <enums name="XrEnvironmentTexturePixelFormatBD" type="enum"> + <enum value="0" name="XR_ENVIRONMENT_TEXTURE_PIXEL_FORMAT_RGB_16FLOAT_BD" comment="RGB 16-bit floating-point format for environment texture data storage with linear encoding, corresponding to GL_RGB16F in OpenGL ES."/> + <enum value="1" name="XR_ENVIRONMENT_TEXTURE_PIXEL_FORMAT_RGBA_16FLOAT_BD" comment="RGBA 16-bit floating-point format for environment texture data storage with linear encoding, corresponding to GL_RGBA16F in OpenGL ES."/> + </enums> + + <enums name="XrSphericalHarmonicsKindBD" type="enum"> + <enum value="0" name="XR_SPHERICAL_HARMONICS_KIND_TOTAL_BD" comment="The spherical harmonic coefficients represent the environment light radiance function, including the contribution from the main light."/> + </enums> + + <!-- XR_META_environment_raycast --> + <enums name="XrEnvironmentRaycastHitStatusMETA" type="enum"> + <enum value="1" name="XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_META" comment="The intersection with the environment is found."/> + <enum value="2" name="XR_ENVIRONMENT_RAYCAST_HIT_STATUS_NO_HIT_META" comment="The intersection with the environment is not found."/> + <enum value="3" name="XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_POINT_OCCLUDED_META" comment="The ray intersects with the environment, but the actual hit point is invisible."/> + <enum value="4" name="XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_POINT_OUTSIDE_OF_FOV_META" comment="The hit point can't be determined because it lies outside of the field of view."/> + <enum value="5" name="XR_ENVIRONMENT_RAYCAST_HIT_STATUS_RAY_OCCLUDED_META" comment="The ray is completely occluded by the environment."/> + <enum value="6" name="XR_ENVIRONMENT_RAYCAST_HIT_STATUS_HIT_INVALID_ORIENTATION_META" comment="The intersection with the environment is found, but the hit orientation cannot be determined."/> + </enums> + + <!-- XR_QCOM_hand_tracking_gesture --> + <enums name="XrHandGestureTypeQCOM" type="enum"> + <enum value="-1" name="XR_HAND_GESTURE_TYPE_UNKNOWN_QCOM" comment="Indicates that no gesture can be detected."/> + <enum value="0" name="XR_HAND_GESTURE_TYPE_OPEN_HAND_QCOM" comment="The open hand gesture is a neutral position. It is performed by extending the hand with the fingers opened and the palm away from the user."/> + <enum value="2" name="XR_HAND_GESTURE_TYPE_GRAB_QCOM" comment="The grab gesture is performed by placing the hand in front of the user and closing the hand into a fist."/> + <enum value="7" name="XR_HAND_GESTURE_TYPE_PINCH_QCOM" comment="The pinch gesture is performed by touching the tip of the thumb to the tip of the index finger while extending the remaining fingers."/> + </enums> + + <!-- XR_EXT_haptic_parametric --> + <enums name="XrHapticParametricStreamFrameTypeEXT" type="enum"> + <enum value="0" name="XR_HAPTIC_PARAMETRIC_STREAM_FRAME_TYPE_NONE_EXT"/> + <enum value="1" name="XR_HAPTIC_PARAMETRIC_STREAM_FRAME_TYPE_FIRST_FRAME_EXT"/> + <enum value="2" name="XR_HAPTIC_PARAMETRIC_STREAM_FRAME_TYPE_INTERMEDIATE_FRAME_EXT"/> + <enum value="3" name="XR_HAPTIC_PARAMETRIC_STREAM_FRAME_TYPE_LAST_FRAME_EXT"/> + </enums> + + <!-- XR_BD_camera_image --> + <enums name="XrCameraPropertyTypeBD" type="enum"> + <enum value="1" name="XR_CAMERA_PROPERTY_TYPE_FACING_BD" comment="The camera's facing orientation."/> + <enum value="2" name="XR_CAMERA_PROPERTY_TYPE_POSITION_BD" comment="The camera's position."/> + <enum value="3" name="XR_CAMERA_PROPERTY_TYPE_CAMERA_TYPE_BD" comment="The camera's type."/> + </enums> + + <enums name="XrCameraFacingBD" type="enum"> + <enum value="1" name="XR_CAMERA_FACING_WORLD_BD" comment="The camera's facing orientation is the world."/> + </enums> + + <enums name="XrCameraPositionBD" type="enum"> + <enum value="1" name="XR_CAMERA_POSITION_UNSPECIFIED_BD" comment="The camera's position is unspecified."/> + <enum value="2" name="XR_CAMERA_POSITION_LEFT_BD" comment="The camera's position is left."/> + <enum value="3" name="XR_CAMERA_POSITION_RIGHT_BD" comment="The camera's position is right."/> + </enums> + + <enums name="XrCameraTypeBD" type="enum"> + <enum value="1" name="XR_CAMERA_TYPE_PASSTHROUGH_COLOR_BD" comment="The camera is a passthrough color camera."/> + </enums> + + <enums name="XrCameraCapabilityTypeBD" type="enum"> + <enum value="1" name="XR_CAMERA_CAPABILITY_TYPE_IMAGE_RESOLUTION_AND_FRAME_RATE_BD" comment="The supported image resolutions and frame rates."/> + <enum value="2" name="XR_CAMERA_CAPABILITY_TYPE_IMAGE_FORMAT_BD" comment="The supported image formats."/> + <enum value="3" name="XR_CAMERA_CAPABILITY_TYPE_DATA_TRANSFER_TYPE_BD" comment="The supported data transfer type."/> + <enum value="4" name="XR_CAMERA_CAPABILITY_TYPE_CAMERA_MODEL_BD" comment="The supported camera models."/> + </enums> + + <enums name="XrCameraDataTransferTypeBD" type="enum"> + <enum value="1" name="XR_CAMERA_DATA_TRANSFER_TYPE_RAW_BUFFER_BD" comment="The data transfer type is raw cpu buffer."/> + </enums> + + <enums name="XrCameraImageFormatBD" type="enum"> + <enum value="1" name="XR_CAMERA_IMAGE_FORMAT_RGBA_8888_BD" comment="The image format is RGBA8888, and consecutive pixels are left to right and rows top to bottom."/> + </enums> + + <enums name="XrCameraModelBD" type="enum"> + <enum value="1" name="XR_CAMERA_MODEL_PINHOLE_BD" comment="The camera model is pinhole."/> + </enums> + + <!-- SECTION: OpenXR loader command definitions --> + <!-- openxr_loader_negotiation.h --> + <commands> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_INITIALIZATION_FAILED"> + <proto><type>XrResult</type> <name>xrNegotiateLoaderRuntimeInterface</name></proto> + <param>const <type>XrNegotiateLoaderInfo</type>* <name>loaderInfo</name></param> + <param><type>XrNegotiateRuntimeRequest</type>* <name>runtimeRequest</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_INITIALIZATION_FAILED"> + <proto><type>XrResult</type> <name>xrNegotiateLoaderApiLayerInterface</name></proto> + <param>const <type>XrNegotiateLoaderInfo</type>* <name>loaderInfo</name></param> + <param len="null-terminated">const <type>char</type>* <name>layerName</name></param> + <param><type>XrNegotiateApiLayerRequest</type>* <name>apiLayerRequest</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_INITIALIZATION_FAILED"> + <proto><type>XrResult</type> <name>xrCreateApiLayerInstance</name></proto> + <param>const <type>XrInstanceCreateInfo</type>* <name>info</name></param> + <param>const <type>XrApiLayerCreateInfo</type>* <name>layerInfo</name></param> + <param><type>XrInstance</type>* <name>instance</name></param> + </command> + </commands> + + + <!-- XR_ML_world_mesh_detection --> + <enums name="XrWorldMeshDetectorFlagBitsML" type="bitmask"> + <enum bitpos="0" name="XR_WORLD_MESH_DETECTOR_POINT_CLOUD_BIT_ML" comment="If set, will return a point cloud instead of a triangle mesh."/> + <enum bitpos="1" name="XR_WORLD_MESH_DETECTOR_COMPUTE_NORMALS_BIT_ML" comment="If set, the system will compute the normals for the triangle vertices."/> + <enum bitpos="2" name="XR_WORLD_MESH_DETECTOR_COMPUTE_CONFIDENCE_BIT_ML" comment="If set, the system will compute the confidence values."/> + <enum bitpos="3" name="XR_WORLD_MESH_DETECTOR_PLANARIZE_BIT_ML" comment="If set, the system will planarize the returned mesh (planar regions will be smoothed out)."/> + <enum bitpos="4" name="XR_WORLD_MESH_DETECTOR_REMOVE_MESH_SKIRT_BIT_ML" comment="If set, the mesh skirt (overlapping area between two mesh blocks) will be removed."/> + <enum bitpos="5" name="XR_WORLD_MESH_DETECTOR_INDEX_ORDER_CW_BIT_ML" comment="If set, winding order of indices will be be changed from counter clockwise to clockwise."/> + </enums> + + <enums name="XrWorldMeshDetectorLodML" type="enum"> + <enum value="0" name="XR_WORLD_MESH_DETECTOR_LOD_MINIMUM_ML" comment="Minimum Level of Detail (LOD) for the mesh."/> + <enum value="1" name="XR_WORLD_MESH_DETECTOR_LOD_MEDIUM_ML" comment="Medium Level of Detail (LOD) for the mesh."/> + <enum value="2" name="XR_WORLD_MESH_DETECTOR_LOD_MAXIMUM_ML" comment="Maximum Level of Detail (LOD) for the mesh."/> + </enums> + + <enums name="XrWorldMeshBlockStatusML" type="enum"> + <enum value="0" name="XR_WORLD_MESH_BLOCK_STATUS_NEW_ML" comment="The mesh block has been created."/> + <enum value="1" name="XR_WORLD_MESH_BLOCK_STATUS_UPDATED_ML" comment="The mesh block has been updated."/> + <enum value="2" name="XR_WORLD_MESH_BLOCK_STATUS_DELETED_ML" comment="The mesh block has been deleted."/> + <enum value="3" name="XR_WORLD_MESH_BLOCK_STATUS_UNCHANGED_ML" comment="The mesh block is unchanged."/> + </enums> + + <enums name="XrWorldMeshBlockResultML" type="enum"> + <enum value="0" name="XR_WORLD_MESH_BLOCK_RESULT_SUCCESS_ML" comment="Mesh request has succeeded."/> + <enum value="1" name="XR_WORLD_MESH_BLOCK_RESULT_FAILED_ML" comment="Mesh request has failed."/> + <enum value="2" name="XR_WORLD_MESH_BLOCK_RESULT_PENDING_ML" comment="Mesh request is pending."/> + <enum value="3" name="XR_WORLD_MESH_BLOCK_RESULT_PARTIAL_UPDATE_ML" comment="There are partial updates on the mesh request."/> + </enums> + + <!-- enums for XR_BD_facial_simulation --> + <enums name="XrFacialSimulationModeBD" type="enum"> + <enum value="0" name="XR_FACIAL_SIMULATION_MODE_DEFAULT_BD" comment="When calling flink:xrGetFacialSimulationDataBD, the output contains the slink:XrFacialSimulationDataBD only."/> + <enum value="1" name="XR_FACIAL_SIMULATION_MODE_COMBINED_AUDIO_BD" comment="Results in the same output as the `Default` mode, furthermore, runtime can provide a precise result by using the audio input."/> + <enum value="2" name="XR_FACIAL_SIMULATION_MODE_COMBINED_AUDIO_WITH_LIP_BD" comment="Separates the result into two parts, one is slink:XrFacialSimulationDataBD, the other is slink:XrLipExpressionDataBD."/> + <enum value="3" name="XR_FACIAL_SIMULATION_MODE_ONLY_AUDIO_WITH_LIP_BD" comment="Uses only audio input to produce the output result as slink:XrLipExpressionDataBD."/> + </enums> + + <enums name="XrFaceExpressionBD" type="enum"> + <enum value="0" name="XR_FACE_EXPRESSION_BROW_DROP_L_BD"/> + <enum value="1" name="XR_FACE_EXPRESSION_BROW_DROP_R_BD"/> + <enum value="2" name="XR_FACE_EXPRESSION_BROW_INNER_UPWARDS_BD"/> + <enum value="3" name="XR_FACE_EXPRESSION_BROW_OUTER_UPWARDS_L_BD"/> + <enum value="4" name="XR_FACE_EXPRESSION_BROW_OUTER_UPWARDS_R_BD"/> + <enum value="5" name="XR_FACE_EXPRESSION_EYE_BLINK_L_BD"/> + <enum value="6" name="XR_FACE_EXPRESSION_EYE_LOOK_DROP_L_BD"/> + <enum value="7" name="XR_FACE_EXPRESSION_EYE_LOOK_IN_L_BD"/> + <enum value="8" name="XR_FACE_EXPRESSION_EYE_LOOK_OUT_L_BD"/> + <enum value="9" name="XR_FACE_EXPRESSION_EYE_LOOK_UPWARDS_L_BD"/> + <enum value="10" name="XR_FACE_EXPRESSION_EYE_LOOK_SQUINT_L_BD"/> + <enum value="11" name="XR_FACE_EXPRESSION_EYE_LOOK_WIDE_L_BD"/> + <enum value="12" name="XR_FACE_EXPRESSION_EYE_BLINK_R_BD"/> + <enum value="13" name="XR_FACE_EXPRESSION_EYE_LOOK_DROP_R_BD"/> + <enum value="14" name="XR_FACE_EXPRESSION_EYE_LOOK_IN_R_BD"/> + <enum value="15" name="XR_FACE_EXPRESSION_EYE_LOOK_OUT_R_BD"/> + <enum value="16" name="XR_FACE_EXPRESSION_EYE_LOOK_UPWARDS_R_BD"/> + <enum value="17" name="XR_FACE_EXPRESSION_EYE_LOOK_SQUINT_R_BD"/> + <enum value="18" name="XR_FACE_EXPRESSION_EYE_LOOK_WIDE_R_BD"/> + <enum value="19" name="XR_FACE_EXPRESSION_NOSE_SNEER_L_BD"/> + <enum value="20" name="XR_FACE_EXPRESSION_NOSE_SNEER_R_BD"/> + <enum value="21" name="XR_FACE_EXPRESSION_CHEEK_PUFF_BD"/> + <enum value="22" name="XR_FACE_EXPRESSION_CHEEK_SQUINT_L_BD"/> + <enum value="23" name="XR_FACE_EXPRESSION_CHEEK_SQUINT_R_BD"/> + <enum value="24" name="XR_FACE_EXPRESSION_MOUTH_CLOSE_BD"/> + <enum value="25" name="XR_FACE_EXPRESSION_MOUTH_FUNNEL_BD"/> + <enum value="26" name="XR_FACE_EXPRESSION_MOUTH_PUCKER_BD"/> + <enum value="27" name="XR_FACE_EXPRESSION_MOUTH_L_BD"/> + <enum value="28" name="XR_FACE_EXPRESSION_MOUTH_R_BD"/> + <enum value="29" name="XR_FACE_EXPRESSION_MOUTH_SMILE_L_BD"/> + <enum value="30" name="XR_FACE_EXPRESSION_MOUTH_SMILE_R_BD"/> + <enum value="31" name="XR_FACE_EXPRESSION_MOUTH_FROWN_L_BD"/> + <enum value="32" name="XR_FACE_EXPRESSION_MOUTH_FROWN_R_BD"/> + <enum value="33" name="XR_FACE_EXPRESSION_MOUTH_DIMPLE_L_BD"/> + <enum value="34" name="XR_FACE_EXPRESSION_MOUTH_DIMPLE_R_BD"/> + <enum value="35" name="XR_FACE_EXPRESSION_MOUTH_STRETCH_L_BD"/> + <enum value="36" name="XR_FACE_EXPRESSION_MOUTH_STRETCH_R_BD"/> + <enum value="37" name="XR_FACE_EXPRESSION_MOUTH_ROLL_LOWER_BD"/> + <enum value="38" name="XR_FACE_EXPRESSION_MOUTH_ROLL_UPPER_BD"/> + <enum value="39" name="XR_FACE_EXPRESSION_MOUTH_SHRUG_LOWER_BD"/> + <enum value="40" name="XR_FACE_EXPRESSION_MOUTH_SHRUG_UPPER_BD"/> + <enum value="41" name="XR_FACE_EXPRESSION_MOUTH_PRESS_L_BD"/> + <enum value="42" name="XR_FACE_EXPRESSION_MOUTH_PRESS_R_BD"/> + <enum value="43" name="XR_FACE_EXPRESSION_MOUTH_LOWER_DROP_L_BD"/> + <enum value="44" name="XR_FACE_EXPRESSION_MOUTH_LOWER_DROP_R_BD"/> + <enum value="45" name="XR_FACE_EXPRESSION_MOUTH_UPPER_UPWARDS_L_BD"/> + <enum value="46" name="XR_FACE_EXPRESSION_MOUTH_UPPER_UPWARDS_R_BD"/> + <enum value="47" name="XR_FACE_EXPRESSION_JAW_FORWARD_BD"/> + <enum value="48" name="XR_FACE_EXPRESSION_JAW_L_BD"/> + <enum value="49" name="XR_FACE_EXPRESSION_JAW_R_BD"/> + <enum value="50" name="XR_FACE_EXPRESSION_JAW_OPEN_BD"/> + <enum value="51" name="XR_FACE_EXPRESSION_TONGUE_OUT_BD"/> + </enums> + + <enums name="XrLipExpressionBD" type="enum"> + <enum value="0" name="XR_LIP_EXPRESSION_PP_BD"/> + <enum value="1" name="XR_LIP_EXPRESSION_CH_BD"/> + <enum value="2" name="XR_LIP_EXPRESSION_LO_BD"/> + <enum value="3" name="XR_LIP_EXPRESSION_O_BD"/> + <enum value="4" name="XR_LIP_EXPRESSION_I_BD"/> + <enum value="5" name="XR_LIP_EXPRESSION_LU_BD"/> + <enum value="6" name="XR_LIP_EXPRESSION_RR_BD"/> + <enum value="7" name="XR_LIP_EXPRESSION_XX_BD"/> + <enum value="8" name="XR_LIP_EXPRESSION_LAA_BD"/> + <enum value="9" name="XR_LIP_EXPRESSION_LI_BD"/> + <enum value="10" name="XR_LIP_EXPRESSION_FF_BD"/> + <enum value="11" name="XR_LIP_EXPRESSION_U_BD"/> + <enum value="12" name="XR_LIP_EXPRESSION_TH_BD"/> + <enum value="13" name="XR_LIP_EXPRESSION_LKK_BD"/> + <enum value="14" name="XR_LIP_EXPRESSION_SS_BD"/> + <enum value="15" name="XR_LIP_EXPRESSION_LE_BD"/> + <enum value="16" name="XR_LIP_EXPRESSION_DD_BD"/> + <enum value="17" name="XR_LIP_EXPRESSION_E_BD"/> + <enum value="18" name="XR_LIP_EXPRESSION_LNN_BD"/> + <enum value="19" name="XR_LIP_EXPRESSION_SIL_BD"/> + </enums> + + <!-- XR_ANDROID_geospatial --> + <enums name="XrGeospatialTrackerStateANDROID" type="enum"> + <enum value="0" name="XR_GEOSPATIAL_TRACKER_STATE_STOPPED_ANDROID" comment="The Geospatial Tracker is not running."/> + <enum value="1" name="XR_GEOSPATIAL_TRACKER_STATE_RUNNING_ANDROID" comment="The Geospatial tracker is running and usable."/> + <enum value="2" name="XR_GEOSPATIAL_TRACKER_STATE_INITIALIZATION_FAILED_ANDROID" comment="The Geospatial Tracker failed to initialize, and will never be usable."/> + </enums> + <enums name="XrGeospatialPoseFlagBitsANDROID" type="bitmask"> + <enum bitpos="0" name="XR_GEOSPATIAL_POSE_ORIENTATION_VALID_BIT_ANDROID" comment="Indicates that the orientation member contains valid data"/> + <enum bitpos="1" name="XR_GEOSPATIAL_POSE_POSITION_VALID_BIT_ANDROID" comment="Indicates that the position member contains valid data"/> + </enums> + <enums name="XrVPSAvailabilityANDROID" type="enum"> + <enum value="1" name="XR_VPS_AVAILABILITY_UNAVAILABLE_ANDROID" comment="VPS is not available near the given location."/> + <enum value="2" name="XR_VPS_AVAILABILITY_AVAILABLE_ANDROID" comment="VPS is available near the given location."/> + </enums> + + <!-- XR_ANDROID_trackables_image --> + <enums name="XrTrackableImageFormatANDROID" type="enum"> + <enum value="1" name="XR_TRACKABLE_IMAGE_FORMAT_R8G8B8A8_ANDROID" comment="RGBA image format with 8 bits per channel color and transparency data."/> + </enums> + + <enums name="XrTrackableImageTrackingModeANDROID" type="enum"> + <enum value="1" name="XR_TRACKABLE_IMAGE_TRACKING_MODE_DYNAMIC_ANDROID" comment="This mode has the highest accuracy and allows low latency tracking of moving images. It has also has the highest power consumption."/> + <enum value="2" name="XR_TRACKABLE_IMAGE_TRACKING_MODE_STATIC_ANDROID" comment="This mode should be used for images that are known to be static or semi-static. This mode leads to less power consumption in comparison to the dynamic mode. If a static image is being moved, it will be updated with a much higher latency than using the dynamic mode."/> + </enums> + + <!-- XR_EXT_interaction_profile_battery_state_display --> + <enums name="XrBatteryStateDisplayStateFlagBitsEXT" type="bitmask"> + <enum bitpos="0" name="XR_BATTERY_STATE_DISPLAY_STATE_VALID_BIT_EXT" comment="Indicates validity of slink:XrBatteryStateDisplayEXT::pname:batteryLevel"/> + <enum bitpos="1" name="XR_BATTERY_STATE_DISPLAY_STATE_CHARGING_BIT_EXT" comment="Indicates that the device associated with the interaction profile is charging."/> + <enum bitpos="2" name="XR_BATTERY_STATE_DISPLAY_STATE_PLUGGED_IN_BIT_EXT" comment="Indicates that the device associated with the interaction profile is plugged in to a power source."/> + <enum bitpos="3" name="XR_BATTERY_STATE_DISPLAY_STATE_NO_BATTERY_BIT_EXT" comment="Indicates that the device associated with the interaction profile does not have a battery power source."/> + </enums> + + <!-- XR_ANDROID_google_cloud_auth --> + <enums name="XrGoogleCloudAuthErrorANDROID" type="enum"> + <enum value="0" name="XR_GOOGLE_CLOUD_AUTH_ERROR_NONE_ANDROID" comment="No error occurred when invoking a Google Cloud API."/> + <enum value="-1" name="XR_GOOGLE_CLOUD_AUTH_ERROR_QUOTA_EXCEEDED_ANDROID" comment="Quota exceeded when invoking a Google Cloud API."/> + <enum value="-2" name="XR_GOOGLE_CLOUD_AUTH_ERROR_UNREACHABLE_ANDROID" comment="Failed to reach a Google Cloud API, possibly due to network connectivity issues or server availability."/> + <enum value="-3" name="XR_GOOGLE_CLOUD_AUTH_ERROR_ANDROID" comment="An auth error occurred when invoking a Google Cloud API."/> + </enums> + + <!-- XR_ANDROID_geospatial_anchor --> + <enums name="XrSurfaceAnchorTypeANDROID" type="enum"> + <enum value="1" name="XR_SURFACE_ANCHOR_TYPE_TERRAIN_ANDROID" comment="Type of an anchor placed relative to the ground."/> + <enum value="2" name="XR_SURFACE_ANCHOR_TYPE_ROOFTOP_ANDROID" comment="Type of an anchor placed relative to the rooftop, or ground where there is no building."/> + </enums> + + <!-- XR_META_hand_tracking_frequency_hint --> + <enums name="XrHandTrackingFrequencyHintMETA" type="enum"> + <enum value="1" name="XR_HAND_TRACKING_FREQUENCY_HINT_DEFAULT_META"/> + <enum value="2" name="XR_HAND_TRACKING_FREQUENCY_HINT_HIGH_META"/> + </enums> + + <!-- XR_SONY_swapchain_color_space --> + <enums name="XrColorSpaceSONY" type="enum"> + <enum value="0" name="XR_COLOR_SPACE_SRGB_NONLINEAR_SONY" comment="sRGB color space, encoded according to the sRGB specification."/> + <enum value="1" name="XR_COLOR_SPACE_DISPLAY_P3_LINEAR_SONY" comment="Display-P3 color space, encoded using a linear transfer function."/> + <enum value="2" name="XR_COLOR_SPACE_DISPLAY_P3_NONLINEAR_SONY" comment="Display-P3 color space, encoded according to the Display-P3 specification."/> + <enum value="3" name="XR_COLOR_SPACE_DCI_P3_LINEAR_SONY" comment="DCI-P3 color space, encoded using a linear transfer function."/> + <enum value="4" name="XR_COLOR_SPACE_DCI_P3_NONLINEAR_SONY" comment="DCI-P3 color space, encoded according to the DCI-P3 specification."/> + <enum value="5" name="XR_COLOR_SPACE_EXTENDED_SRGB_LINEAR_SONY" comment="Extended sRGB color space, encoded using a linear transfer function."/> + <enum value="6" name="XR_COLOR_SPACE_BT709_LINEAR_SONY" comment="ITU-R BT.709 color space, encoded using a linear transfer function."/> + <enum value="7" name="XR_COLOR_SPACE_BT709_NONLINEAR_SONY" comment="ITU-R BT.709 color space, encoded according to the BT.709 specification."/> + <enum value="8" name="XR_COLOR_SPACE_BT2020_LINEAR_SONY" comment="ITU-R BT.2020 color space, encoded using a linear transfer function."/> + <enum value="9" name="XR_COLOR_SPACE_BT2020_PQ_SONY" comment="ITU-R BT.2020 color space, encoded according to the SMPTE ST 2084 Perceptual Quantizer (PQ) specification."/> + <enum value="10" name="XR_COLOR_SPACE_BT2020_HLG_SONY" comment="ITU-R BT.2020 color space, encoded according to the Hybrid Log Gamma (HLG) specification."/> + </enums> + + <!-- XR_ANDROID_trackables --> + <enums name="XrTrackingStateANDROID" type="enum"> + <enum value="0" name="XR_TRACKING_STATE_PAUSED_ANDROID" comment="Indicates that the trackable or anchor tracking is paused but may be resumed in the future."/> + <enum value="1" name="XR_TRACKING_STATE_STOPPED_ANDROID" comment="Tracking has stopped on this Trackable and will never be resumed."/> + <enum value="2" name="XR_TRACKING_STATE_TRACKING_ANDROID" comment="The object is currently tracked and its pose is current."/> + </enums> + <enums name="XrTrackableTypeANDROID" type="enum"> + <enum value="0" name="XR_TRACKABLE_TYPE_NOT_VALID_ANDROID" comment="Indicates that the trackable is not valid."/> + <enum value="1" name="XR_TRACKABLE_TYPE_PLANE_ANDROID" comment="Indicates that the trackable is a plane."/> + </enums> + <enums name="XrPlaneTypeANDROID" type="enum"> + <enum value="0" name="XR_PLANE_TYPE_HORIZONTAL_DOWNWARD_FACING_ANDROID" comment="A horizontal plane facing downward (for example a ceiling)."/> + <enum value="1" name="XR_PLANE_TYPE_HORIZONTAL_UPWARD_FACING_ANDROID" comment="A horizontal plane facing upward (for example a floor or tabletop)."/> + <enum value="2" name="XR_PLANE_TYPE_VERTICAL_ANDROID" comment="A vertical plane (for example a wall)."/> + <enum value="3" name="XR_PLANE_TYPE_ARBITRARY_ANDROID" comment="A plane with an arbitrary orientation."/> + </enums> + <enums name="XrPlaneLabelANDROID" type="enum"> + <enum value="0" name="XR_PLANE_LABEL_UNKNOWN_ANDROID" comment="It was not possible to label the plane"/> + <enum value="1" name="XR_PLANE_LABEL_WALL_ANDROID" comment="The plane is a wall."/> + <enum value="2" name="XR_PLANE_LABEL_FLOOR_ANDROID" comment="The plane is a floor."/> + <enum value="3" name="XR_PLANE_LABEL_CEILING_ANDROID" comment="The plane is a ceiling."/> + <enum value="4" name="XR_PLANE_LABEL_TABLE_ANDROID" comment="The plane is a table."/> + </enums> + + <!-- XR_EXT_spatial_container --> + <enums name="XrSpatialContainerGraphicsPresentationEXT" type="enum"> + </enums> + <enums name="XrSpatialContainerBoundsModeEXT" type="enum"> + <enum value="1" name="XR_SPATIAL_CONTAINER_BOUNDS_MODE_BOUNDED_EXT" comment="Spatial container is bounded. The bounds are a finite box. The spatial container will only appear in this region."/> + <enum value="2" name="XR_SPATIAL_CONTAINER_BOUNDS_MODE_IMMERSIVE_EXT" comment="Spatial container is immersive and has infinite bounds. The spatial container is displayed over the entire screen."/> + </enums> + <enums name="XrSpatialContainerVolumeClippingEXT" type="enum"> + <enum value="0" name="XR_SPATIAL_CONTAINER_VOLUME_CLIPPING_NONE_EXT" comment="No content is clipped to the bounding volume of the spatial container. Content can draw outside of the spatial container's bounds."/> + <enum value="1" name="XR_SPATIAL_CONTAINER_VOLUME_CLIPPING_STRICT_EXT" comment="Content is strictly clipped to the bounding volume of the spatial container."/> + </enums> + + <!-- XR_EXT_spatial_image_tracking --> + <enums name="XrSpatialReferenceImageFormatEXT" type="enum"> + <enum value="1" name="XR_SPATIAL_REFERENCE_IMAGE_FORMAT_RGBA_8888_EXT" comment="An RGBA buffer. The format makes no guarantees regarding the layout of the pixel data in memory. The pixels must: be accessed using the metadata provided by the corresponding slink:XrSpatialReferenceImagePlaneEXT structures. Each pixel color channel has an 8 bit size, making each pixel 32 bit in size."/> + <enum value="2" name="XR_SPATIAL_REFERENCE_IMAGE_FORMAT_RGB_888_EXT" comment="An RGB buffer. The format makes no guarantees regarding the layout of the pixel data in memory. The pixels must: be accessed using the metadata provided by the corresponding slink:XrSpatialReferenceImagePlaneEXT structures. Each pixel color channel has an 8 bit size, making each pixel 24 bit in size."/> + <enum value="3" name="XR_SPATIAL_REFERENCE_IMAGE_FORMAT_YUV_420_888_EXT" comment="A YUV buffer that is 4:2:0 pattern chroma sub-sampled. The format makes no guarantees regarding the layout of the pixel data in memory. The pixels must: be accessed using the metadata provided by the corresponding slink:XrSpatialReferenceImagePlaneEXT structures. Each decoded RGB pixel color channel has an 8 bit size, making each pixel 24 bit in size."/> + </enums> + + <!-- SECTION: OpenXR command definitions --> + <commands> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetInstanceProcAddr</name></proto> + <param optional="true"><type>XrInstance</type> <name>instance</name></param> + <param len="null-terminated">const <type>char</type>* <name>name</name></param> + <param><type>PFN_xrVoidFunction</type>* <name>function</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateApiLayerProperties</name></proto> + <param optional="true"><type>uint32_t</type> <name>propertyCapacityInput</name></param> + <param><type>uint32_t</type>* <name>propertyCountOutput</name></param> + <param optional="true" len="propertyCapacityInput"><type>XrApiLayerProperties</type>* <name>properties</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_API_LAYER_NOT_PRESENT,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_RUNTIME_UNAVAILABLE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateInstanceExtensionProperties</name></proto> + <param optional="true" len="null-terminated">const <type>char</type>* <name>layerName</name></param> + <param optional="true"><type>uint32_t</type> <name>propertyCapacityInput</name></param> + <param><type>uint32_t</type>* <name>propertyCountOutput</name></param> + <param optional="true" len="propertyCapacityInput"><type>XrExtensionProperties</type>* <name>properties</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_API_LAYER_NOT_PRESENT,XR_ERROR_API_VERSION_UNSUPPORTED,XR_ERROR_EXTENSION_DEPENDENCY_NOT_ENABLED,XR_ERROR_EXTENSION_NOT_PRESENT,XR_ERROR_INITIALIZATION_FAILED,XR_ERROR_LIMIT_REACHED,XR_ERROR_NAME_INVALID,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_RUNTIME_UNAVAILABLE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateInstance</name></proto> + <param>const <type>XrInstanceCreateInfo</type>* <name>createInfo</name></param> + <param><type>XrInstance</type>* <name>instance</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyInstance</name></proto> + <param externsync="true_with_children"><type>XrInstance</type> <name>instance</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrResultToString</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrResult</type> <name>value</name></param> + <param><type>char</type> <name>buffer</name>[<enum>XR_MAX_RESULT_STRING_SIZE</enum>]</param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStructureTypeToString</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrStructureType</type> <name>value</name></param> + <param><type>char</type> <name>buffer</name>[<enum>XR_MAX_STRUCTURE_NAME_SIZE</enum>]</param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStructureTypeToString2KHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrStructureType</type> <name>value</name></param> + <param><type>char</type> <name>buffer</name>[<enum>XR_MAX_STRUCTURE_NAME_SIZE_EXTENDED_KHR</enum>]</param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetInstanceProperties</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrInstanceProperties</type>* <name>instanceProperties</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FORM_FACTOR_UNAVAILABLE,XR_ERROR_FORM_FACTOR_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSystem</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrSystemGetInfo</type>* <name>getInfo</name></param> + <param><type>XrSystemId</type>* <name>systemId</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSystemProperties</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrSystemProperties</type>* <name>properties</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_GRAPHICS_DEVICE_INVALID,XR_ERROR_GRAPHICS_REQUIREMENTS_CALL_MISSING,XR_ERROR_HANDLE_INVALID,XR_ERROR_INITIALIZATION_FAILED,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSession</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrSessionCreateInfo</type>* <name>createInfo</name></param> + <param><type>XrSession</type>* <name>session</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySession</name></proto> + <param externsync="true_with_children"><type>XrSession</type> <name>session</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpace</name></proto> + <param externsync="true_with_children"><type>XrSpace</type> <name>space</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSwapchainFormats</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true"><type>uint32_t</type> <name>formatCapacityInput</name></param> + <param><type>uint32_t</type>* <name>formatCountOutput</name></param> + <param optional="true" len="formatCapacityInput"><type>int64_t</type>* <name>formats</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSwapchain</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSwapchainCreateInfo</type>* <name>createInfo</name></param> + <param><type>XrSwapchain</type>* <name>swapchain</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySwapchain</name></proto> + <param externsync="true_with_children"><type>XrSwapchain</type> <name>swapchain</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSwapchainImages</name></proto> + <param><type>XrSwapchain</type> <name>swapchain</name></param> + <param optional="true"><type>uint32_t</type> <name>imageCapacityInput</name></param> + <param><type>uint32_t</type>* <name>imageCountOutput</name></param> + <param optional="true" len="imageCapacityInput"><type>XrSwapchainImageBaseHeader</type>* <name>images</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrAcquireSwapchainImage</name></proto> + <param><type>XrSwapchain</type> <name>swapchain</name></param> + <param optional="true">const <type>XrSwapchainImageAcquireInfo</type>* <name>acquireInfo</name></param> + <param><type>uint32_t</type>* <name>index</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING,XR_TIMEOUT_EXPIRED" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrWaitSwapchainImage</name></proto> + <param><type>XrSwapchain</type> <name>swapchain</name></param> + <param>const <type>XrSwapchainImageWaitInfo</type>* <name>waitInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrReleaseSwapchainImage</name></proto> + <param><type>XrSwapchain</type> <name>swapchain</name></param> + <param optional="true">const <type>XrSwapchainImageReleaseInfo</type>* <name>releaseInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_READY,XR_ERROR_SESSION_RUNNING,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED"> + <proto><type>XrResult</type> <name>xrBeginSession</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSessionBeginInfo</type>* <name>beginInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_SESSION_NOT_STOPPING,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEndSession</name></proto> + <param><type>XrSession</type> <name>session</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRequestExitSession</name></proto> + <param><type>XrSession</type> <name>session</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateReferenceSpaces</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true"><type>uint32_t</type> <name>spaceCapacityInput</name></param> + <param><type>uint32_t</type>* <name>spaceCountOutput</name></param> + <param optional="true" len="spaceCapacityInput"><type>XrReferenceSpaceType</type>* <name>spaces</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_REFERENCE_SPACE_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateReferenceSpace</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrReferenceSpaceCreateInfo</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>space</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ACTION_TYPE_MISMATCH,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateActionSpace</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrActionSpaceCreateInfo</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>space</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrLocateSpace</name></proto> + <param><type>XrSpace</type> <name>space</name></param> + <param><type>XrSpace</type> <name>baseSpace</name></param> + <param><type>XrTime</type> <name>time</name></param> + <param><type>XrSpaceLocation</type>* <name>location</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateViewConfigurations</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param optional="true"><type>uint32_t</type> <name>viewConfigurationTypeCapacityInput</name></param> + <param><type>uint32_t</type>* <name>viewConfigurationTypeCountOutput</name></param> + <param optional="true" len="viewConfigurationTypeCapacityInput"><type>XrViewConfigurationType</type>* <name>viewConfigurationTypes</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED"> + <proto><type>XrResult</type> <name>xrEnumerateEnvironmentBlendModes</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></param> + <param optional="true"><type>uint32_t</type> <name>environmentBlendModeCapacityInput</name></param> + <param><type>uint32_t</type>* <name>environmentBlendModeCountOutput</name></param> + <param optional="true" len="environmentBlendModeCapacityInput"><type>XrEnvironmentBlendMode</type>* <name>environmentBlendModes</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED"> + <proto><type>XrResult</type> <name>xrGetViewConfigurationProperties</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></param> + <param><type>XrViewConfigurationProperties</type>* <name>configurationProperties</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED"> + <proto><type>XrResult</type> <name>xrEnumerateViewConfigurationViews</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></param> + <param optional="true"><type>uint32_t</type> <name>viewCapacityInput</name></param> + <param><type>uint32_t</type>* <name>viewCountOutput</name></param> + <param optional="true" len="viewCapacityInput"><type>XrViewConfigurationView</type>* <name>views</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_FRAME_DISCARDED,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrBeginFrame</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true">const <type>XrFrameBeginInfo</type>* <name>frameBeginInfo</name></param> + <implicitexternsyncparams> + <param>the pname:session parameter by any other flink:xrBeginFrame or flink:xrEndFrame call</param> + </implicitexternsyncparams> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED"> + <proto><type>XrResult</type> <name>xrLocateViews</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrViewLocateInfo</type>* <name>viewLocateInfo</name></param> + <param><type>XrViewState</type>* <name>viewState</name></param> + <param optional="true"><type>uint32_t</type> <name>viewCapacityInput</name></param> + <param><type>uint32_t</type>* <name>viewCountOutput</name></param> + <param optional="true" len="viewCapacityInput"><type>XrView</type>* <name>views</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_ENVIRONMENT_BLEND_MODE_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LAYER_INVALID,XR_ERROR_LAYER_LIMIT_EXCEEDED,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_SWAPCHAIN_RECT_INVALID,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEndFrame</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrFrameEndInfo</type>* <name>frameEndInfo</name></param> + <implicitexternsyncparams> + <param>the pname:session parameter by any other flink:xrBeginFrame or flink:xrEndFrame call</param> + </implicitexternsyncparams> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrWaitFrame</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true">const <type>XrFrameWaitInfo</type>* <name>frameWaitInfo</name></param> + <param><type>XrFrameState</type>* <name>frameState</name></param> + <implicitexternsyncparams> + <param>the pname:session parameter by any other flink:xrWaitFrame call</param> + </implicitexternsyncparams> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING,XR_SESSION_NOT_FOCUSED" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_ACTION_TYPE_MISMATCH,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrApplyHapticFeedback</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrHapticActionInfo</type>* <name>hapticActionInfo</name></param> + <param>const <type>XrHapticBaseHeader</type>* <name>hapticFeedback</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING,XR_SESSION_NOT_FOCUSED" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_ACTION_TYPE_MISMATCH,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStopHapticFeedback</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrHapticActionInfo</type>* <name>hapticActionInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_EVENT_UNAVAILABLE" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPollEvent</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrEventDataBuffer</type>* <name>eventData</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_COUNT_EXCEEDED,XR_ERROR_PATH_FORMAT_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStringToPath</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param len="null-terminated">const <type>char</type>* <name>pathString</name></param> + <param><type>XrPath</type>* <name>path</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPathToString</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrPath</type> <name>path</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>char</type>* <name>buffer</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING,XR_SPACE_BOUNDS_UNAVAILABLE" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_REFERENCE_SPACE_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetReferenceSpaceBoundsRect</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrReferenceSpaceType</type> <name>referenceSpaceType</name></param> + <param><type>XrExtent2Df</type>* <name>bounds</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ANDROID_THREAD_SETTINGS_FAILURE_KHR,XR_ERROR_ANDROID_THREAD_SETTINGS_ID_INVALID_KHR,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetAndroidApplicationThreadKHR</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrAndroidThreadTypeKHR</type> <name>threadType</name></param> + <param><type>uint32_t</type> <name>threadId</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSwapchainAndroidSurfaceKHR</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSwapchainCreateInfo</type>* <name>info</name></param> + <param><type>XrSwapchain</type>* <name>swapchain</name></param> + <param><type>jobject</type>* <name>surface</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_ACTION_TYPE_MISMATCH,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetActionStateBoolean</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrActionStateGetInfo</type>* <name>getInfo</name></param> + <param><type>XrActionStateBoolean</type>* <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_ACTION_TYPE_MISMATCH,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetActionStateFloat</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrActionStateGetInfo</type>* <name>getInfo</name></param> + <param><type>XrActionStateFloat</type>* <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_ACTION_TYPE_MISMATCH,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetActionStateVector2f</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrActionStateGetInfo</type>* <name>getInfo</name></param> + <param><type>XrActionStateVector2f</type>* <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_ACTION_TYPE_MISMATCH,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetActionStatePose</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrActionStateGetInfo</type>* <name>getInfo</name></param> + <param><type>XrActionStatePose</type>* <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_LOCALIZED_NAME_DUPLICATED,XR_ERROR_LOCALIZED_NAME_INVALID,XR_ERROR_NAME_DUPLICATED,XR_ERROR_NAME_INVALID,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PATH_FORMAT_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateActionSet</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrActionSetCreateInfo</type>* <name>createInfo</name></param> + <param><type>XrActionSet</type>* <name>actionSet</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyActionSet</name></proto> + <param externsync="true_with_children"><type>XrActionSet</type> <name>actionSet</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_ACTIONSETS_ALREADY_ATTACHED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_LOCALIZED_NAME_DUPLICATED,XR_ERROR_LOCALIZED_NAME_INVALID,XR_ERROR_NAME_DUPLICATED,XR_ERROR_NAME_INVALID,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PATH_FORMAT_INVALID,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateAction</name></proto> + <param><type>XrActionSet</type> <name>actionSet</name></param> + <param>const <type>XrActionCreateInfo</type>* <name>createInfo</name></param> + <param><type>XrAction</type>* <name>action</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyAction</name></proto> + <param externsync="true_with_children"><type>XrAction</type> <name>action</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_ACTIONSETS_ALREADY_ATTACHED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSuggestInteractionProfileBindings</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrInteractionProfileSuggestedBinding</type>* <name>suggestedBindings</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ACTIONSETS_ALREADY_ATTACHED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrAttachSessionActionSets</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSessionActionSetsAttachInfo</type>* <name>attachInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetCurrentInteractionProfile</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPath</type> <name>topLevelUserPath</name></param> + <param><type>XrInteractionProfileState</type>* <name>interactionProfile</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING,XR_SESSION_NOT_FOCUSED" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSyncActions</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrActionsSyncInfo</type>* <name>syncInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateBoundSourcesForAction</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrBoundSourcesForActionEnumerateInfo</type>* <name>enumerateInfo</name></param> + <param optional="true"><type>uint32_t</type> <name>sourceCapacityInput</name></param> + <param><type>uint32_t</type>* <name>sourceCountOutput</name></param> + <param optional="true" len="sourceCapacityInput"><type>XrPath</type>* <name>sources</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetInputSourceLocalizedName</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrInputSourceLocalizedNameGetInfo</type>* <name>getInfo</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>char</type>* <name>buffer</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetVulkanInstanceExtensionsKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>char</type>* <name>buffer</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetVulkanDeviceExtensionsKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>char</type>* <name>buffer</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetVulkanGraphicsDeviceKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>VkInstance</type> <name>vkInstance</name></param> + <param><type>VkPhysicalDevice</type>* <name>vkPhysicalDevice</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetOpenGLGraphicsRequirementsKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrGraphicsRequirementsOpenGLKHR</type>* <name>graphicsRequirements</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetOpenGLESGraphicsRequirementsKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrGraphicsRequirementsOpenGLESKHR</type>* <name>graphicsRequirements</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetVulkanGraphicsRequirementsKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrGraphicsRequirementsVulkanKHR</type>* <name>graphicsRequirements</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetD3D11GraphicsRequirementsKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrGraphicsRequirementsD3D11KHR</type>* <name>graphicsRequirements</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetD3D12GraphicsRequirementsKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrGraphicsRequirementsD3D12KHR</type>* <name>graphicsRequirements</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetMetalGraphicsRequirementsKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrGraphicsRequirementsMetalKHR</type>* <name>graphicsRequirements</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPerfSettingsSetPerformanceLevelEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPerfSettingsDomainEXT</type> <name>domain</name></param> + <param><type>XrPerfSettingsLevelEXT</type> <name>level</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrThermalGetTemperatureTrendEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPerfSettingsDomainEXT</type> <name>domain</name></param> + <param><type>XrPerfSettingsNotificationLevelEXT</type>* <name>notificationLevel</name></param> + <param><type>float</type>* <name>tempHeadroom</name></param> + <param><type>float</type>* <name>tempSlope</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetDebugUtilsObjectNameEXT</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param externsync="nameInfo.objectHandle">const <type>XrDebugUtilsObjectNameInfoEXT</type>* <name>nameInfo</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateDebugUtilsMessengerEXT</name></proto> + <param externsync="true_with_children"><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrDebugUtilsMessengerCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrDebugUtilsMessengerEXT</type>* <name>messenger</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyDebugUtilsMessengerEXT</name></proto> + <param externsync="true"><type>XrDebugUtilsMessengerEXT</type> <name>messenger</name></param> + <implicitexternsyncparams> + <param>the slink:XrInstance used to create pname:messenger, and all of its child handles</param> + </implicitexternsyncparams> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSubmitDebugUtilsMessageEXT</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrDebugUtilsMessageSeverityFlagsEXT</type> <name>messageSeverity</name></param> + <param><type>XrDebugUtilsMessageTypeFlagsEXT</type> <name>messageTypes</name></param> + <param>const <type>XrDebugUtilsMessengerCallbackDataEXT</type>* <name>callbackData</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSessionBeginDebugUtilsLabelRegionEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrDebugUtilsLabelEXT</type>* <name>labelInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSessionEndDebugUtilsLabelRegionEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSessionInsertDebugUtilsLabelEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrDebugUtilsLabelEXT</type>* <name>labelInfo</name></param> + </command> + + <!-- commands for XR_KHR_win32_convert_performance_counter_time --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrConvertTimeToWin32PerformanceCounterKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrTime</type> <name>time</name></param> + <param><type>LARGE_INTEGER</type>* <name>performanceCounter</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrConvertWin32PerformanceCounterToTimeKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>LARGE_INTEGER</type>* <name>performanceCounter</name></param> + <param><type>XrTime</type>* <name>time</name></param> + </command> + + <!-- commands for XR_KHR_vulkan_enable2 --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateVulkanInstanceKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrVulkanInstanceCreateInfoKHR</type>* <name>createInfo</name></param> + <param><type>VkInstance</type>* <name>vulkanInstance</name></param> + <param><type>VkResult</type>* <name>vulkanResult</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateVulkanDeviceKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrVulkanDeviceCreateInfoKHR</type>* <name>createInfo</name></param> + <param><type>VkDevice</type>* <name>vulkanDevice</name></param> + <param><type>VkResult</type>* <name>vulkanResult</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetVulkanGraphicsDevice2KHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrVulkanGraphicsDeviceGetInfoKHR</type>* <name>getInfo</name></param> + <param><type>VkPhysicalDevice</type>* <name>vulkanPhysicalDevice</name></param> + </command> + <command name="xrGetVulkanGraphicsRequirements2KHR" alias="xrGetVulkanGraphicsRequirementsKHR"/> + + <!-- commands for XR_KHR_convert_timespec_time --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrConvertTimeToTimespecTimeKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrTime</type> <name>time</name></param> + <param>struct <type>timespec</type>* <name>timespecTime</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrConvertTimespecTimeToTimeKHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const struct <type>timespec</type>* <name>timespecTime</name></param> + <param><type>XrTime</type>* <name>time</name></param> + </command> + + <!-- commands for XR_KHR_visibility_mask --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED"> + <proto><type>XrResult</type> <name>xrGetVisibilityMaskKHR</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></param> + <param><type>uint32_t</type> <name>viewIndex</name></param> + <param><type>XrVisibilityMaskTypeKHR</type> <name>visibilityMaskType</name></param> + <param><type>XrVisibilityMaskKHR</type>* <name>visibilityMask</name></param> + </command> + + <!-- commands for XR_MSFT_spatial_anchor --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CREATE_SPATIAL_ANCHOR_FAILED_MSFT,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialAnchorCreateInfoMSFT</type>* <name>createInfo</name></param> + <param><type>XrSpatialAnchorMSFT</type>* <name>anchor</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorSpaceMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialAnchorSpaceCreateInfoMSFT</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>space</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpatialAnchorMSFT</name></proto> + <param externsync="true_with_children"><type>XrSpatialAnchorMSFT</type> <name>anchor</name></param> + </command> + + <!-- commands for XR_EXT_conformance_automation --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetInputDeviceActiveEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPath</type> <name>interactionProfile</name></param> + <param><type>XrPath</type> <name>topLevelPath</name></param> + <param><type>XrBool32</type> <name>isActive</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetInputDeviceStateBoolEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPath</type> <name>topLevelPath</name></param> + <param><type>XrPath</type> <name>inputSourcePath</name></param> + <param><type>XrBool32</type> <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetInputDeviceStateFloatEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPath</type> <name>topLevelPath</name></param> + <param><type>XrPath</type> <name>inputSourcePath</name></param> + <param><type>float</type> <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetInputDeviceStateVector2fEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPath</type> <name>topLevelPath</name></param> + <param><type>XrPath</type> <name>inputSourcePath</name></param> + <param><type>XrVector2f</type> <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetInputDeviceLocationEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPath</type> <name>topLevelPath</name></param> + <param><type>XrPath</type> <name>inputSourcePath</name></param> + <param><type>XrSpace</type> <name>space</name></param> + <param><type>XrPosef</type> <name>pose</name></param> + </command> + + <!-- commands for XR_KHR_loader_init --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrInitializeLoaderKHR</name></proto> + <param>const <type>XrLoaderInitInfoBaseHeaderKHR</type>* <name>loaderInitInfo</name></param> + </command> + + <!-- commands for XR_MSFT_spatial_graph_bridge --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialGraphNodeSpaceMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialGraphNodeSpaceCreateInfoMSFT</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>space</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrTryCreateSpatialGraphStaticNodeBindingMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialGraphStaticNodeBindingCreateInfoMSFT</type>* <name>createInfo</name></param> + <param><type>XrSpatialGraphNodeBindingMSFT</type>* <name>nodeBinding</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpatialGraphNodeBindingMSFT</name></proto> + <param externsync="true_with_children"><type>XrSpatialGraphNodeBindingMSFT</type> <name>nodeBinding</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialGraphNodeBindingPropertiesMSFT</name></proto> + <param><type>XrSpatialGraphNodeBindingMSFT</type> <name>nodeBinding</name></param> + <param optional="true">const <type>XrSpatialGraphNodeBindingPropertiesGetInfoMSFT</type>* <name>getInfo</name></param> + <param><type>XrSpatialGraphNodeBindingPropertiesMSFT</type>* <name>properties</name></param> + </command> + + <!-- XR_EXT_hand_tracking --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateHandTrackerEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrHandTrackerCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrHandTrackerEXT</type>* <name>handTracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyHandTrackerEXT</name></proto> + <param externsync="true_with_children"><type>XrHandTrackerEXT</type> <name>handTracker</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrLocateHandJointsEXT</name></proto> + <param><type>XrHandTrackerEXT</type> <name>handTracker</name></param> + <param>const <type>XrHandJointsLocateInfoEXT</type>* <name>locateInfo</name></param> + <param><type>XrHandJointLocationsEXT</type>* <name>locations</name></param> + </command> + + <!-- XR_FB_face_tracking --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateFaceTrackerFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrFaceTrackerCreateInfoFB</type>* <name>createInfo</name></param> + <param><type>XrFaceTrackerFB</type>* <name>faceTracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyFaceTrackerFB</name></proto> + <param externsync="true_with_children"><type>XrFaceTrackerFB</type> <name>faceTracker</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetFaceExpressionWeightsFB</name></proto> + <param><type>XrFaceTrackerFB</type> <name>faceTracker</name></param> + <param>const <type>XrFaceExpressionInfoFB</type>* <name>expressionInfo</name></param> + <param><type>XrFaceExpressionWeightsFB</type>* <name>expressionWeights</name></param> + </command> + + <!-- XR_FB_face_tracking2 --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateFaceTracker2FB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrFaceTrackerCreateInfo2FB</type>* <name>createInfo</name></param> + <param><type>XrFaceTracker2FB</type>* <name>faceTracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyFaceTracker2FB</name></proto> + <param externsync="true_with_children"><type>XrFaceTracker2FB</type> <name>faceTracker</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetFaceExpressionWeights2FB</name></proto> + <param><type>XrFaceTracker2FB</type> <name>faceTracker</name></param> + <param>const <type>XrFaceExpressionInfo2FB</type>* <name>expressionInfo</name></param> + <param><type>XrFaceExpressionWeights2FB</type>* <name>expressionWeights</name></param> + </command> + + <!-- XR_FB_body_tracking --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateBodyTrackerFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrBodyTrackerCreateInfoFB</type>* <name>createInfo</name></param> + <param><type>XrBodyTrackerFB</type>* <name>bodyTracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyBodyTrackerFB</name></proto> + <param externsync="true_with_children"><type>XrBodyTrackerFB</type> <name>bodyTracker</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrLocateBodyJointsFB</name></proto> + <param><type>XrBodyTrackerFB</type> <name>bodyTracker</name></param> + <param>const <type>XrBodyJointsLocateInfoFB</type>* <name>locateInfo</name></param> + <param><type>XrBodyJointLocationsFB</type>* <name>locations</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetBodySkeletonFB</name></proto> + <param><type>XrBodyTrackerFB</type> <name>bodyTracker</name></param> + <param><type>XrBodySkeletonFB</type>* <name>skeleton</name></param> + </command> + + <!-- XR_META_body_tracking_calibration --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSuggestBodyTrackingCalibrationOverrideMETA</name></proto> + <param><type>XrBodyTrackerFB</type> <name>bodyTracker</name></param> + <param>const <type>XrBodyTrackingCalibrationInfoMETA</type>* <name>calibrationInfo</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrResetBodyTrackingCalibrationMETA</name></proto> + <param><type>XrBodyTrackerFB</type> <name>bodyTracker</name></param> + </command> + + <!-- XR_FB_eye_tracking_social --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateEyeTrackerFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrEyeTrackerCreateInfoFB</type>* <name>createInfo</name></param> + <param><type>XrEyeTrackerFB</type>* <name>eyeTracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyEyeTrackerFB</name></proto> + <param externsync="true_with_children"><type>XrEyeTrackerFB</type> <name>eyeTracker</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetEyeGazesFB</name></proto> + <param><type>XrEyeTrackerFB</type> <name>eyeTracker</name></param> + <param>const <type>XrEyeGazesInfoFB</type>* <name>gazeInfo</name></param> + <param><type>XrEyeGazesFB</type>* <name>eyeGazes</name></param> + </command> + + <!-- XR_MSFT_hand_tracking_mesh --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateHandMeshSpaceMSFT</name></proto> + <param><type>XrHandTrackerEXT</type> <name>handTracker</name></param> + <param>const <type>XrHandMeshSpaceCreateInfoMSFT</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>space</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUpdateHandMeshMSFT</name></proto> + <param><type>XrHandTrackerEXT</type> <name>handTracker</name></param> + <param>const <type>XrHandMeshUpdateInfoMSFT</type>* <name>updateInfo</name></param> + <param><type>XrHandMeshMSFT</type>* <name>handMesh</name></param> + </command> + + <!-- XR_MSFT_controller_model --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CONTROLLER_MODEL_KEY_INVALID_MSFT,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetControllerModelKeyMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPath</type> <name>topLevelUserPath</name></param> + <param><type>XrControllerModelKeyStateMSFT</type>* <name>controllerModelKeyState</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CONTROLLER_MODEL_KEY_INVALID_MSFT,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrLoadControllerModelMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrControllerModelKeyMSFT</type> <name>modelKey</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>uint8_t</type>* <name>buffer</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CONTROLLER_MODEL_KEY_INVALID_MSFT,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetControllerModelPropertiesMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrControllerModelKeyMSFT</type> <name>modelKey</name></param> + <param><type>XrControllerModelPropertiesMSFT</type>* <name>properties</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CONTROLLER_MODEL_KEY_INVALID_MSFT,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetControllerModelStateMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrControllerModelKeyMSFT</type> <name>modelKey</name></param> + <param><type>XrControllerModelStateMSFT</type>* <name>state</name></param> + </command> + + <!-- XR_MSFT_scene_understanding --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSceneComputeFeaturesMSFT</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param optional="true"><type>uint32_t</type> <name>featureCapacityInput</name></param> + <param><type>uint32_t</type>* <name>featureCountOutput</name></param> + <param optional="true" len="featureCapacityInput"><type>XrSceneComputeFeatureMSFT</type>* <name>features</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSceneObserverMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true">const <type>XrSceneObserverCreateInfoMSFT</type>* <name>createInfo</name></param> + <param><type>XrSceneObserverMSFT</type>* <name>sceneObserver</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySceneObserverMSFT</name></proto> + <param externsync="true_with_children"><type>XrSceneObserverMSFT</type> <name>sceneObserver</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_COMPUTE_NEW_SCENE_NOT_COMPLETED_MSFT,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSceneMSFT</name></proto> + <param><type>XrSceneObserverMSFT</type> <name>sceneObserver</name></param> + <param optional="true">const <type>XrSceneCreateInfoMSFT</type>* <name>createInfo</name></param> + <param><type>XrSceneMSFT</type>* <name>scene</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySceneMSFT</name></proto> + <param externsync="true_with_children"><type>XrSceneMSFT</type> <name>scene</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_COMPUTE_NEW_SCENE_NOT_COMPLETED_MSFT,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SCENE_COMPUTE_CONSISTENCY_MISMATCH_MSFT,XR_ERROR_SCENE_COMPUTE_FEATURE_INCOMPATIBLE_MSFT,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrComputeNewSceneMSFT</name></proto> + <param><type>XrSceneObserverMSFT</type> <name>sceneObserver</name></param> + <param>const <type>XrNewSceneComputeInfoMSFT</type>* <name>computeInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSceneComputeStateMSFT</name></proto> + <param><type>XrSceneObserverMSFT</type> <name>sceneObserver</name></param> + <param><type>XrSceneComputeStateMSFT</type>* <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SCENE_COMPONENT_TYPE_MISMATCH_MSFT,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSceneComponentsMSFT</name></proto> + <param><type>XrSceneMSFT</type> <name>scene</name></param> + <param>const <type>XrSceneComponentsGetInfoMSFT</type>* <name>getInfo</name></param> + <param><type>XrSceneComponentsMSFT</type>* <name>components</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrLocateSceneComponentsMSFT</name></proto> + <param><type>XrSceneMSFT</type> <name>scene</name></param> + <param>const <type>XrSceneComponentsLocateInfoMSFT</type>* <name>locateInfo</name></param> + <param><type>XrSceneComponentLocationsMSFT</type>* <name>locations</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SCENE_COMPONENT_ID_INVALID_MSFT,XR_ERROR_SCENE_MESH_BUFFER_ID_INVALID_MSFT,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSceneMeshBuffersMSFT</name></proto> + <param><type>XrSceneMSFT</type> <name>scene</name></param> + <param>const <type>XrSceneMeshBuffersGetInfoMSFT</type>* <name>getInfo</name></param> + <param><type>XrSceneMeshBuffersMSFT</type>* <name>buffers</name></param> + </command> + + <!-- XR_MSFT_scene_understanding_serialization --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_COMPUTE_NEW_SCENE_NOT_COMPLETED_MSFT,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrDeserializeSceneMSFT</name></proto> + <param><type>XrSceneObserverMSFT</type> <name>sceneObserver</name></param> + <param>const <type>XrSceneDeserializeInfoMSFT</type>* <name>deserializeInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SCENE_COMPONENT_ID_INVALID_MSFT,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSerializedSceneFragmentDataMSFT</name></proto> + <param><type>XrSceneMSFT</type> <name>scene</name></param> + <param>const <type>XrSerializedSceneFragmentDataGetInfoMSFT</type>* <name>getInfo</name></param> + <param optional="true"><type>uint32_t</type> <name>countInput</name></param> + <param><type>uint32_t</type>* <name>readOutput</name></param> + <param optional="true" len="countInput"><type>uint8_t</type>* <name>buffer</name></param> + </command> + + <!-- XR_MSFT_scene_marker --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SCENE_COMPONENT_ID_INVALID_MSFT,XR_ERROR_SCENE_COMPONENT_TYPE_MISMATCH_MSFT,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSceneMarkerRawDataMSFT</name></proto> + <param><type>XrSceneMSFT</type> <name>scene</name></param> + <param>const <type>XrUuidMSFT</type>* <name>markerId</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>uint8_t</type>* <name>buffer</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SCENE_MARKER_DATA_NOT_STRING_MSFT,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SCENE_COMPONENT_ID_INVALID_MSFT,XR_ERROR_SCENE_COMPONENT_TYPE_MISMATCH_MSFT,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSceneMarkerDecodedStringMSFT</name></proto> + <param><type>XrSceneMSFT</type> <name>scene</name></param> + <param>const <type>XrUuidMSFT</type>* <name>markerId</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>char</type>* <name>buffer</name></param> + </command> + + <!-- XR_FB_display_refresh_rate --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateDisplayRefreshRatesFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true"><type>uint32_t</type> <name>displayRefreshRateCapacityInput</name></param> + <param><type>uint32_t</type>* <name>displayRefreshRateCountOutput</name></param> + <param optional="true" len="displayRefreshRateCapacityInput"><type>float</type>* <name>displayRefreshRates</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetDisplayRefreshRateFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>float</type>* <name>displayRefreshRate</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_DISPLAY_REFRESH_RATE_UNSUPPORTED_FB,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRequestDisplayRefreshRateFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>float</type> <name>displayRefreshRate</name></param> + </command> + + <!-- XR_MSFT_perception_anchor_interop --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorFromPerceptionAnchorMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>IUnknown</type>* <name>perceptionAnchor</name></param> + <param><type>XrSpatialAnchorMSFT</type>* <name>anchor</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrTryGetPerceptionAnchorFromSpatialAnchorMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrSpatialAnchorMSFT</type> <name>anchor</name></param> + <param><type>IUnknown</type>** <name>perceptionAnchor</name></param> + </command> + + <!-- XR_FB_swapchain_update_state --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUpdateSwapchainFB</name></proto> + <param><type>XrSwapchain</type> <name>swapchain</name></param> + <param>const <type>XrSwapchainStateBaseHeaderFB</type>* <name>state</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSwapchainStateFB</name></proto> + <param><type>XrSwapchain</type> <name>swapchain</name></param> + <param><type>XrSwapchainStateBaseHeaderFB</type>* <name>state</name></param> + </command> + + <!-- XR_FB_color_space --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateColorSpacesFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true"><type>uint32_t</type> <name>colorSpaceCapacityInput</name></param> + <param><type>uint32_t</type>* <name>colorSpaceCountOutput</name></param> + <param optional="true" len="colorSpaceCapacityInput"><type>XrColorSpaceFB</type>* <name>colorSpaces</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_COLOR_SPACE_UNSUPPORTED_FB,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetColorSpaceFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrColorSpaceFB</type> <name>colorSpace</name></param> + </command> + + <!-- XR_FB_foveation --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateFoveationProfileFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrFoveationProfileCreateInfoFB</type>* <name>createInfo</name></param> + <param><type>XrFoveationProfileFB</type>* <name>profile</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyFoveationProfileFB</name></proto> + <param externsync="true_with_children"><type>XrFoveationProfileFB</type> <name>profile</name></param> + </command> + + <!-- XR_META_foveation_eye_tracked --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetFoveationEyeTrackedStateMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrFoveationEyeTrackedStateMETA</type>* <name>foveationState</name></param> + </command> + + <!-- XR_FB_hand_tracking_mesh --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetHandMeshFB</name></proto> + <param><type>XrHandTrackerEXT</type> <name>handTracker</name></param> + <param><type>XrHandTrackingMeshFB</type>* <name>mesh</name></param> + </command> + + <!-- XR_FB_render_model --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateRenderModelPathsFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true"><type>uint32_t</type> <name>pathCapacityInput</name></param> + <param><type>uint32_t</type>* <name>pathCountOutput</name></param> + <param optional="true" len="pathCapacityInput"><type>XrRenderModelPathInfoFB</type>* <name>paths</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_RENDER_MODEL_UNAVAILABLE_FB,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetRenderModelPropertiesFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPath</type> <name>path</name></param> + <param><type>XrRenderModelPropertiesFB</type>* <name>properties</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_RENDER_MODEL_UNAVAILABLE_FB,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RENDER_MODEL_KEY_INVALID_FB,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrLoadRenderModelFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrRenderModelLoadInfoFB</type>* <name>info</name></param> + <param><type>XrRenderModelBufferFB</type>* <name>buffer</name></param> + </command> + + <!-- XR_FB_keyboard_tracking --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrQuerySystemTrackedKeyboardFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrKeyboardTrackingQueryFB</type>* <name>queryInfo</name></param> + <param><type>XrKeyboardTrackingDescriptionFB</type>* <name>keyboard</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateKeyboardSpaceFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrKeyboardSpaceCreateInfoFB</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>keyboardSpace</name></param> + </command> + + <!-- commands for XR_VARJO_environment_depth_estimation --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST"> + <proto><type>XrResult</type> <name>xrSetEnvironmentDepthEstimationVARJO</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrBool32</type> <name>enabled</name></param> + </command> + + <!-- XR_MSFT_composition_layer_reprojection --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED"> + <proto><type>XrResult</type> <name>xrEnumerateReprojectionModesMSFT</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrViewConfigurationType</type> <name>viewConfigurationType</name></param> + <param optional="true"><type>uint32_t</type> <name>modeCapacityInput</name></param> + <param><type>uint32_t</type>* <name>modeCountOutput</name></param> + <param optional="true" len="modeCapacityInput"><type>XrReprojectionModeMSFT</type>* <name>modes</name></param> + </command> + + <!-- commands for XR_OCULUS_audio_device_guid --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetAudioOutputDeviceGuidOculus</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>wchar_t</type> <name>buffer</name>[<enum>XR_MAX_AUDIO_DEVICE_STR_SIZE_OCULUS</enum>]</param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetAudioInputDeviceGuidOculus</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>wchar_t</type> <name>buffer</name>[<enum>XR_MAX_AUDIO_DEVICE_STR_SIZE_OCULUS</enum>]</param> + </command> + + <!-- XR_FB_spatial_entity --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialAnchorCreateInfoFB</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceUuidFB</name></proto> + <param><type>XrSpace</type> <name>space</name></param> + <param><type>XrUuidEXT</type>* <name>uuid</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSpaceSupportedComponentsFB</name></proto> + <param><type>XrSpace</type> <name>space</name></param> + <param optional="true"><type>uint32_t</type> <name>componentTypeCapacityInput</name></param> + <param><type>uint32_t</type>* <name>componentTypeCountOutput</name></param> + <param optional="true" len="componentTypeCapacityInput"><type>XrSpaceComponentTypeFB</type>* <name>componentTypes</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPACE_COMPONENT_NOT_SUPPORTED_FB,XR_ERROR_SPACE_COMPONENT_STATUS_ALREADY_SET_FB,XR_ERROR_SPACE_COMPONENT_STATUS_PENDING_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetSpaceComponentStatusFB</name></proto> + <param><type>XrSpace</type> <name>space</name></param> + <param>const <type>XrSpaceComponentStatusSetInfoFB</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPACE_COMPONENT_NOT_SUPPORTED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceComponentStatusFB</name></proto> + <param><type>XrSpace</type> <name>space</name></param> + <param><type>XrSpaceComponentTypeFB</type> <name>componentType</name></param> + <param><type>XrSpaceComponentStatusFB</type>* <name>status</name></param> + </command> + + <!-- XR_FB_triangle_mesh --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_INSUFFICIENT_RESOURCES_PASSTHROUGH_FB,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateTriangleMeshFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrTriangleMeshCreateInfoFB</type>* <name>createInfo</name></param> + <param><type>XrTriangleMeshFB</type>* <name>outTriangleMesh</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyTriangleMeshFB</name></proto> + <param externsync="true_with_children"><type>XrTriangleMeshFB</type> <name>mesh</name></param> + <implicitexternsyncparams> + <param>the buffers returned from calls to flink:xrTriangleMeshGetVertexBufferFB and flink:xrTriangleMeshGetIndexBufferFB on pname:mesh</param> + </implicitexternsyncparams> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrTriangleMeshGetVertexBufferFB</name></proto> + <param><type>XrTriangleMeshFB</type> <name>mesh</name></param> + <param><type>XrVector3f</type>** <name>outVertexBuffer</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrTriangleMeshGetIndexBufferFB</name></proto> + <param><type>XrTriangleMeshFB</type> <name>mesh</name></param> + <param><type>uint32_t</type>** <name>outIndexBuffer</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrTriangleMeshBeginUpdateFB</name></proto> + <param><type>XrTriangleMeshFB</type> <name>mesh</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrTriangleMeshEndUpdateFB</name></proto> + <param><type>XrTriangleMeshFB</type> <name>mesh</name></param> + <param><type>uint32_t</type> <name>vertexCount</name></param> + <param><type>uint32_t</type> <name>triangleCount</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrTriangleMeshBeginVertexBufferUpdateFB</name></proto> + <param><type>XrTriangleMeshFB</type> <name>mesh</name></param> + <param><type>uint32_t</type>* <name>outVertexCount</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrTriangleMeshEndVertexBufferUpdateFB</name></proto> + <param><type>XrTriangleMeshFB</type> <name>mesh</name></param> + </command> + + <!-- XR_FB_passthrough --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_ALREADY_CREATED_PASSTHROUGH_FB,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_NOT_PERMITTED_PASSTHROUGH_FB,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_UNKNOWN_PASSTHROUGH_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreatePassthroughFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrPassthroughCreateInfoFB</type>* <name>createInfo</name></param> + <param><type>XrPassthroughFB</type>* <name>outPassthrough</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyPassthroughFB</name></proto> + <param externsync="true_with_children"><type>XrPassthroughFB</type> <name>passthrough</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_UNEXPECTED_STATE_PASSTHROUGH_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPassthroughStartFB</name></proto> + <param><type>XrPassthroughFB</type> <name>passthrough</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_UNEXPECTED_STATE_PASSTHROUGH_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPassthroughPauseFB</name></proto> + <param><type>XrPassthroughFB</type> <name>passthrough</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_REQUIRED_PASSTHROUGH_FB,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_INSUFFICIENT_RESOURCES_PASSTHROUGH_FB,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_UNKNOWN_PASSTHROUGH_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreatePassthroughLayerFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrPassthroughLayerCreateInfoFB</type>* <name>createInfo</name></param> + <param><type>XrPassthroughLayerFB</type>* <name>outLayer</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyPassthroughLayerFB</name></proto> + <param externsync="true_with_children"><type>XrPassthroughLayerFB</type> <name>layer</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_UNEXPECTED_STATE_PASSTHROUGH_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPassthroughLayerPauseFB</name></proto> + <param><type>XrPassthroughLayerFB</type> <name>layer</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_UNEXPECTED_STATE_PASSTHROUGH_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPassthroughLayerResumeFB</name></proto> + <param><type>XrPassthroughLayerFB</type> <name>layer</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPassthroughLayerSetStyleFB</name></proto> + <param><type>XrPassthroughLayerFB</type> <name>layer</name></param> + <param>const <type>XrPassthroughStyleFB</type>* <name>style</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_INSUFFICIENT_RESOURCES_PASSTHROUGH_FB,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateGeometryInstanceFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrGeometryInstanceCreateInfoFB</type>* <name>createInfo</name></param> + <param><type>XrGeometryInstanceFB</type>* <name>outGeometryInstance</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyGeometryInstanceFB</name></proto> + <param externsync="true_with_children"><type>XrGeometryInstanceFB</type> <name>instance</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGeometryInstanceSetTransformFB</name></proto> + <param><type>XrGeometryInstanceFB</type> <name>instance</name></param> + <param>const <type>XrGeometryInstanceTransformFB</type>* <name>transformation</name></param> + </command> + + <!-- XR_FB_spatial_entity_query --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrQuerySpacesFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpaceQueryInfoBaseHeaderFB</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRetrieveSpaceQueryResultsFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrAsyncRequestIdFB</type> <name>requestId</name></param> + <param><type>XrSpaceQueryResultsFB</type>* <name>results</name></param> + </command> + + <!-- XR_FB_spatial_entity_storage --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSaveSpaceFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpaceSaveInfoFB</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEraseSpaceFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpaceEraseInfoFB</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + + <!-- XR_FB_spatial_entity_storage_batch --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPACE_CLOUD_STORAGE_DISABLED_FB,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_SPACE_LOCALIZATION_FAILED_FB,XR_ERROR_SPACE_MAPPING_INSUFFICIENT_FB,XR_ERROR_SPACE_NETWORK_REQUEST_FAILED_FB,XR_ERROR_SPACE_NETWORK_TIMEOUT_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSaveSpaceListFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpaceListSaveInfoFB</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + + <!-- XR_FB_spatial_entity_sharing --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPACE_CLOUD_STORAGE_DISABLED_FB,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_SPACE_LOCALIZATION_FAILED_FB,XR_ERROR_SPACE_MAPPING_INSUFFICIENT_FB,XR_ERROR_SPACE_NETWORK_REQUEST_FAILED_FB,XR_ERROR_SPACE_NETWORK_TIMEOUT_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrShareSpacesFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpaceShareInfoFB</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + + <!-- XR_FB_spatial_entity_container --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceContainerFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrSpace</type> <name>space</name></param> + <param><type>XrSpaceContainerFB</type>* <name>spaceContainerOutput</name></param> + </command> + + <!-- XR_META_spatial_entity_mesh --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceTriangleMeshMETA</name></proto> + <param><type>XrSpace</type> <name>space</name></param> + <param>const <type>XrSpaceTriangleMeshGetInfoMETA</type>* <name>getInfo</name></param> + <param><type>XrSpaceTriangleMeshMETA</type>* <name>triangleMeshOutput</name></param> + </command> + + <!-- XR_META_spatial_entity_room_mesh --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceRoomMeshMETA</name></proto> + <param><type>XrSpace</type> <name>space</name></param> + <param>const <type>XrSpaceRoomMeshGetInfoMETA</type>* <name>getInfo</name></param> + <param><type>XrRoomMeshMETA</type>* <name>roomMeshOutput</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceRoomMeshFaceIndicesMETA</name></proto> + <param><type>XrSpace</type> <name>space</name></param> + <param>const <type>XrUuid</type>* <name>faceUuid</name></param> + <param><type>XrRoomMeshFaceIndicesMETA</type>* <name>roomMeshFaceIndicesOutput</name></param> + </command> + + <!-- XR_META_boundary_visibility --> + <command successcodes="XR_SUCCESS,XR_BOUNDARY_VISIBILITY_SUPPRESSION_NOT_ALLOWED_META,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRequestBoundaryVisibilityMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrBoundaryVisibilityMETA</type> <name>boundaryVisibility</name></param> + </command> + + <!-- XR_FB_scene --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceBoundingBox2DFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrSpace</type> <name>space</name></param> + <param><type>XrRect2Df</type>* <name>boundingBox2DOutput</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceBoundingBox3DFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrSpace</type> <name>space</name></param> + <param><type>XrRect3DfFB</type>* <name>boundingBox3DOutput</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceSemanticLabelsFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrSpace</type> <name>space</name></param> + <param><type>XrSemanticLabelsFB</type>* <name>semanticLabelsOutput</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceBoundary2DFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrSpace</type> <name>space</name></param> + <param><type>XrBoundary2DFB</type>* <name>boundary2DOutput</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceRoomLayoutFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrSpace</type> <name>space</name></param> + <param><type>XrRoomLayoutFB</type>* <name>roomLayoutOutput</name></param> + </command> + + <!-- XR_FB_scene_capture --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRequestSceneCaptureFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSceneCaptureRequestInfoFB</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + + <!-- XR_FB_passthrough_keyboard_hands --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPassthroughLayerSetKeyboardHandsIntensityFB</name></proto> + <param><type>XrPassthroughLayerFB</type> <name>layer</name></param> + <param>const <type>XrPassthroughKeyboardHandsIntensityFB</type>* <name>intensity</name></param> + </command> + + <!-- XR_META_colocation_discovery --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_EXTENSION_NOT_PRESENT,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_RUNTIME_UNAVAILABLE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStartColocationDiscoveryMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrColocationDiscoveryStartInfoMETA</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>discoveryRequestId</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_EXTENSION_NOT_PRESENT,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_RUNTIME_UNAVAILABLE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStopColocationDiscoveryMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrColocationDiscoveryStopInfoMETA</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_EXTENSION_NOT_PRESENT,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_RUNTIME_UNAVAILABLE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStartColocationAdvertisementMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrColocationAdvertisementStartInfoMETA</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>advertisementRequestId</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_EXTENSION_NOT_PRESENT,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_RUNTIME_UNAVAILABLE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStopColocationAdvertisementMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrColocationAdvertisementStopInfoMETA</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + + <!-- XR_META_spatial_entity_sharing --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrShareSpacesMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrShareSpacesInfoMETA</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + + <!-- XR_MSFT_spatial_anchor_persistence --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorStoreConnectionMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrSpatialAnchorStoreConnectionMSFT</type>* <name>spatialAnchorStore</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpatialAnchorStoreConnectionMSFT</name></proto> + <param externsync="true_with_children"><type>XrSpatialAnchorStoreConnectionMSFT</type> <name>spatialAnchorStore</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPersistSpatialAnchorMSFT</name></proto> + <param><type>XrSpatialAnchorStoreConnectionMSFT</type> <name>spatialAnchorStore</name></param> + <param>const <type>XrSpatialAnchorPersistenceInfoMSFT</type>* <name>spatialAnchorPersistenceInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumeratePersistedSpatialAnchorNamesMSFT</name></proto> + <param><type>XrSpatialAnchorStoreConnectionMSFT</type> <name>spatialAnchorStore</name></param> + <param optional="true"><type>uint32_t</type> <name>spatialAnchorNameCapacityInput</name></param> + <param><type>uint32_t</type>* <name>spatialAnchorNameCountOutput</name></param> + <param optional="true" len="spatialAnchorNameCapacityInput"><type>XrSpatialAnchorPersistenceNameMSFT</type>* <name>spatialAnchorNames</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT,XR_ERROR_SPATIAL_ANCHOR_NAME_NOT_FOUND_MSFT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorFromPersistedNameMSFT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT</type>* <name>spatialAnchorCreateInfo</name></param> + <param><type>XrSpatialAnchorMSFT</type>* <name>spatialAnchor</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT,XR_ERROR_SPATIAL_ANCHOR_NAME_NOT_FOUND_MSFT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUnpersistSpatialAnchorMSFT</name></proto> + <param><type>XrSpatialAnchorStoreConnectionMSFT</type> <name>spatialAnchorStore</name></param> + <param>const <type>XrSpatialAnchorPersistenceNameMSFT</type>* <name>spatialAnchorPersistenceName</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrClearSpatialAnchorStoreMSFT</name></proto> + <param><type>XrSpatialAnchorStoreConnectionMSFT</type> <name>spatialAnchorStore</name></param> + </command> + + <!-- XR_BD_body_tracking --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateBodyTrackerBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrBodyTrackerCreateInfoBD</type>* <name>createInfo</name></param> + <param><type>XrBodyTrackerBD</type>* <name>bodyTracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyBodyTrackerBD</name></proto> + <param externsync="true_with_children"><type>XrBodyTrackerBD</type> <name>bodyTracker</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrLocateBodyJointsBD</name></proto> + <param><type>XrBodyTrackerBD</type> <name>bodyTracker</name></param> + <param>const <type>XrBodyJointsLocateInfoBD</type>* <name>locateInfo</name></param> + <param><type>XrBodyJointLocationsBD</type>* <name>locations</name></param> + </command> + + <!-- XR_BD_body_tracking_auxiliary_metrics --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStartBodyTrackingCalibrationAppBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetBodyTrackingStateBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrBodyTrackingStateBD</type>* <name>state</name></param> + </command> + + <!-- XR_HTC_facial_tracking --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateFacialTrackerHTC</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrFacialTrackerCreateInfoHTC</type>* <name>createInfo</name></param> + <param><type>XrFacialTrackerHTC</type>* <name>facialTracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyFacialTrackerHTC</name></proto> + <param externsync="true_with_children"><type>XrFacialTrackerHTC</type> <name>facialTracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetFacialExpressionsHTC</name></proto> + <param><type>XrFacialTrackerHTC</type> <name>facialTracker</name></param> + <param><type>XrFacialExpressionsHTC</type>* <name>facialExpressions</name></param> + </command> + + <!-- XR_HTC_passthrough --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreatePassthroughHTC</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrPassthroughCreateInfoHTC</type>* <name>createInfo</name></param> + <param><type>XrPassthroughHTC</type>* <name>passthrough</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyPassthroughHTC</name></proto> + <param externsync="true_with_children"><type>XrPassthroughHTC</type> <name>passthrough</name></param> + </command> + + <!-- XR_HTC_anchor --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_NAME_INVALID,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorHTC</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialAnchorCreateInfoHTC</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>anchor</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_NOT_AN_ANCHOR_HTC,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialAnchorNameHTC</name></proto> + <param><type>XrSpace</type> <name>anchor</name></param> + <param><type>XrSpatialAnchorNameHTC</type>* <name>name</name></param> + </command> + + <!-- XR_HTCX_vive_tracker_interaction --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateViveTrackerPathsHTCX</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param optional="true"><type>uint32_t</type> <name>pathCapacityInput</name></param> + <param><type>uint32_t</type>* <name>pathCountOutput</name></param> + <param optional="true" len="pathCapacityInput"><type>XrViveTrackerPathsHTCX</type>* <name>paths</name></param> + </command> + + <!-- XR_HTC_body_tracking --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateBodyTrackerHTC</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrBodyTrackerCreateInfoHTC</type>* <name>createInfo</name></param> + <param><type>XrBodyTrackerHTC</type>* <name>bodyTracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyBodyTrackerHTC</name></proto> + <param externsync="true_with_children"><type>XrBodyTrackerHTC</type> <name>bodyTracker</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrLocateBodyJointsHTC</name></proto> + <param><type>XrBodyTrackerHTC</type> <name>bodyTracker</name></param> + <param>const <type>XrBodyJointsLocateInfoHTC</type>* <name>locateInfo</name></param> + <param><type>XrBodyJointLocationsHTC</type>* <name>locations</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetBodySkeletonHTC</name></proto> + <param><type>XrBodyTrackerHTC</type> <name>bodyTracker</name></param> + <param><type>XrSpace</type> <name>baseSpace</name></param> + <param><type>uint32_t</type> <name>skeletonGenerationId</name></param> + <param><type>XrBodySkeletonHTC</type>* <name>skeleton</name></param> + </command> + + <!-- commands for XR_VARJO_marker_tracking --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST"> + <proto><type>XrResult</type> <name>xrSetMarkerTrackingVARJO</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrBool32</type> <name>enabled</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_MARKER_ID_INVALID_VARJO,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST"> + <proto><type>XrResult</type> <name>xrSetMarkerTrackingTimeoutVARJO</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>uint64_t</type> <name>markerId</name></param> + <param><type>XrDuration</type> <name>timeout</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_MARKER_ID_INVALID_VARJO,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST"> + <proto><type>XrResult</type> <name>xrSetMarkerTrackingPredictionVARJO</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>uint64_t</type> <name>markerId</name></param> + <param><type>XrBool32</type> <name>enable</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_MARKER_ID_INVALID_VARJO,XR_ERROR_MARKER_NOT_TRACKED_VARJO,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST"> + <proto><type>XrResult</type> <name>xrGetMarkerSizeVARJO</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>uint64_t</type> <name>markerId</name></param> + <param><type>XrExtent2Df</type>* <name>size</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_MARKER_ID_INVALID_VARJO,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateMarkerSpaceVARJO</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrMarkerSpaceCreateInfoVARJO</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>space</name></param> + </command> + + <!-- XR_META_body_tracking_fidelity --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRequestBodyTrackingFidelityMETA</name></proto> + <param><type>XrBodyTrackerFB</type> <name>bodyTracker</name></param> + <param>const <type>XrBodyTrackingFidelityMETA</type> <name>fidelity</name></param> + </command> + + <!-- commands for XR_ALMALENCE_digital_lens_control --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST"> + <proto><type>XrResult</type> <name>xrSetDigitalLensControlALMALENCE</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrDigitalLensControlALMALENCE</type>* <name>digitalLensControl</name></param> + </command> + + <!-- commands for XR_VARJO_view_offset --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetViewOffsetVARJO</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>float</type> <name>offset</name></param> + </command> + + <!-- commands for XR_OCULUS_external_camera --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateExternalCamerasOCULUS</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true"><type>uint32_t</type> <name>cameraCapacityInput</name></param> + <param><type>uint32_t</type>* <name>cameraCountOutput</name></param> + <param optional="true" len="cameraCapacityInput"><type>XrExternalCameraOCULUS</type>* <name>cameras</name></param> + </command> + + <!-- commands for XR_META_passthrough_color_lut--> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PASSTHROUGH_COLOR_LUT_BUFFER_SIZE_MISMATCH_META,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreatePassthroughColorLutMETA</name></proto> + <param><type>XrPassthroughFB</type> <name>passthrough</name></param> + <param>const <type>XrPassthroughColorLutCreateInfoMETA</type>* <name>createInfo</name></param> + <param><type>XrPassthroughColorLutMETA</type>* <name>colorLut</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyPassthroughColorLutMETA</name></proto> + <param externsync="true_with_children"><type>XrPassthroughColorLutMETA</type> <name>colorLut</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PASSTHROUGH_COLOR_LUT_BUFFER_SIZE_MISMATCH_META,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUpdatePassthroughColorLutMETA</name></proto> + <param><type>XrPassthroughColorLutMETA</type> <name>colorLut</name></param> + <param>const <type>XrPassthroughColorLutUpdateInfoMETA</type>* <name>updateInfo</name></param> + </command> + + <!-- commands for XR_META_performance_metrics --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumeratePerformanceMetricsCounterPathsMETA</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param optional="true"><type>uint32_t</type> <name>counterPathCapacityInput</name></param> + <param><type>uint32_t</type>* <name>counterPathCountOutput</name></param> + <param optional="true" len="counterPathCapacityInput"><type>XrPath</type>* <name>counterPaths</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetPerformanceMetricsStateMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrPerformanceMetricsStateMETA</type>* <name>state</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetPerformanceMetricsStateMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPerformanceMetricsStateMETA</type>* <name>state</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrQueryPerformanceMetricsCounterMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPath</type> <name>counterPath</name></param> + <param><type>XrPerformanceMetricsCounterMETA</type>* <name>counter</name></param> + </command> + + <!-- commands for XR_META_passthrough_preferences --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetPassthroughPreferencesMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPassthroughPreferencesMETA</type>* <name>preferences</name></param> + </command> + + <!-- commands for XR_HTC_foveation --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrApplyFoveationHTC</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrFoveationApplyInfoHTC</type>* <name>applyInfo</name></param> + </command> + + + <!-- commands for XR_ML_compat --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpaceFromCoordinateFrameUIDML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrCoordinateSpaceCreateInfoML</type> *<name>createInfo</name></param> + <param><type>XrSpace</type>* <name>space</name></param> + </command> + + <!-- XR_FB_haptic_pcm --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_ACTION_TYPE_MISMATCH,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetDeviceSampleRateFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrHapticActionInfo</type>* <name>hapticActionInfo</name></param> + <param><type>XrDevicePcmSampleRateGetInfoFB</type>* <name>deviceSampleRate</name></param> + </command> + + <!-- XR_QCOM_tracking_optimization_settings --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_HINT_ALREADY_SET_QCOM,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetTrackingOptimizationSettingsHintQCOM</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrTrackingOptimizationSettingsDomainQCOM</type> <name>domain</name></param> + <param><type>XrTrackingOptimizationSettingsHintQCOM</type> <name>hint</name></param> + </command> + + <!-- commands for XR_FB_spatial_entity_user --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpaceUserFB</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpaceUserCreateInfoFB</type>* <name>info</name></param> + <param><type>XrSpaceUserFB</type>* <name>user</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpaceUserIdFB</name></proto> + <param><type>XrSpaceUserFB</type> <name>user</name></param> + <param><type>XrSpaceUserIdFB</type>* <name>userId</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpaceUserFB</name></proto> + <param externsync="true_with_children"><type>XrSpaceUserFB</type> <name>user</name></param> + </command> + + <!-- XR_META_recommended_layer_resolution commands --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LAYER_INVALID,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetRecommendedLayerResolutionMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrRecommendedLayerResolutionGetInfoMETA</type>* <name>info</name></param> + <param><type>XrRecommendedLayerResolutionMETA</type>* <name>resolution</name></param> + </command> + + <!-- commands for XR_META_spatial_entity_persistence --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING,XR_SESSION_NOT_FOCUSED" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INITIALIZATION_FAILED,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_SPACE_RATE_LIMITED_META,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSaveSpacesMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpacesSaveInfoMETA</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING,XR_SESSION_NOT_FOCUSED" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INITIALIZATION_FAILED,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB,XR_ERROR_SPACE_RATE_LIMITED_META,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEraseSpacesMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpacesEraseInfoMETA</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + + <!-- commands for XR_META_spatial_entity_discovery --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INITIALIZATION_FAILED,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPACE_RATE_LIMITED_META,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrDiscoverSpacesMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpaceDiscoveryInfoMETA</type>* <name>info</name></param> + <param><type>XrAsyncRequestIdFB</type>* <name>requestId</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRetrieveSpaceDiscoveryResultsMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrAsyncRequestIdFB</type> <name>requestId</name></param> + <param><type>XrSpaceDiscoveryResultsMETA</type>* <name>results</name></param> + </command> + + <!-- commands for XR_MNDX_force_feedback_curl --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING,XR_SESSION_NOT_FOCUSED" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrApplyForceFeedbackCurlMNDX</name></proto> + <param><type>XrHandTrackerEXT</type> <name>handTracker</name></param> + <param>const <type>XrForceFeedbackCurlApplyLocationsMNDX</type>* <name>locations</name></param> + </command> + + <!-- commands for XR_ANDROID_face_tracking --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateFaceTrackerANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrFaceTrackerCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrFaceTrackerANDROID</type>* <name>faceTracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyFaceTrackerANDROID</name></proto> + <param externsync="true_with_children"><type>XrFaceTrackerANDROID</type> <name>faceTracker</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SERVICE_NOT_READY_ANDROID,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetFaceStateANDROID</name></proto> + <param><type>XrFaceTrackerANDROID</type> <name>faceTracker</name></param> + <param>const <type>XrFaceStateGetInfoANDROID</type>* <name>getInfo</name></param> + <param><type>XrFaceStateANDROID</type>* <name>faceStateOutput</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetFaceCalibrationStateANDROID</name></proto> + <param><type>XrFaceTrackerANDROID</type> <name>faceTracker</name></param> + <param><type>XrBool32</type>* <name>faceIsCalibratedOutput</name></param> + </command> + + <!-- commands for XR_ANDROID_passthrough_camera_state --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetPassthroughCameraStateANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrPassthroughCameraStateGetInfoANDROID</type>* <name>getInfo</name></param> + <param><type>XrPassthroughCameraStateANDROID</type>* <name>cameraStateOutput</name></param> + </command> + + <!-- XR_ANDROID_anchor_sharing_export --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ANCHOR_NOT_OWNED_BY_CALLER_ANDROID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrShareAnchorANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrAnchorSharingInfoANDROID</type>* <name>sharingInfo</name></param> + <param><type>XrAnchorSharingTokenANDROID</type>* <name>anchorToken</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ANCHOR_NOT_OWNED_BY_CALLER_ANDROID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUnshareAnchorANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrSpace</type> <name>anchor</name></param> + </command> + + <!-- XR_ANDROID_trackables_object --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_MISMATCHING_TRACKABLE_TYPE_ANDROID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetTrackableObjectANDROID</name></proto> + <param><type>XrTrackableTrackerANDROID</type> <name>tracker</name></param> + <param>const <type>XrTrackableGetInfoANDROID</type>* <name>getInfo</name></param> + <param><type>XrTrackableObjectANDROID</type>* <name>objectOutput</name></param> + </command> + + <!-- commands for XR_ANDROID_raycast --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateRaycastSupportedTrackableTypesANDROID</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param optional="true"><type>uint32_t</type> <name>trackableTypeCapacityInput</name></param> + <param><type>uint32_t</type>* <name>trackableTypeCountOutput</name></param> + <param optional="true" len="trackableTypeCapacityInput"><type>XrTrackableTypeANDROID</type>* <name>trackableTypes</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_TRACKABLE_TYPE_NOT_SUPPORTED_ANDROID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRaycastANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrRaycastInfoANDROID</type>* <name>rayInfo</name></param> + <param><type>XrRaycastHitResultsANDROID</type>* <name>results</name></param> + </command> + + <!-- XR_ANDROID_trackables_marker --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_MISMATCHING_TRACKABLE_TYPE_ANDROID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetTrackableMarkerANDROID</name></proto> + <param><type>XrTrackableTrackerANDROID</type> <name>tracker</name></param> + <param>const <type>XrTrackableGetInfoANDROID</type>* <name>getInfo</name></param> + <param><type>XrTrackableMarkerANDROID</type>* <name>markerOutput</name></param> + </command> + + <!-- XR_ANDROID_device_anchor_persistence --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSupportedPersistenceAnchorTypesANDROID</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param optional="true"><type>uint32_t</type> <name>trackableTypeCapacityInput</name></param> + <param><type>uint32_t</type>* <name>trackableTypeCountOutput</name></param> + <param optional="true" len="trackableTypeCapacityInput"><type>XrTrackableTypeANDROID</type>* <name>trackableTypes</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateDeviceAnchorPersistenceANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrDeviceAnchorPersistenceCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrDeviceAnchorPersistenceANDROID</type>* <name>outHandle</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyDeviceAnchorPersistenceANDROID</name></proto> + <param externsync="true_with_children"><type>XrDeviceAnchorPersistenceANDROID</type> <name>handle</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ANCHOR_NOT_OWNED_BY_CALLER_ANDROID,XR_ERROR_ANCHOR_NOT_TRACKING_ANDROID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERSISTED_DATA_NOT_READY_ANDROID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPersistAnchorANDROID</name></proto> + <param><type>XrDeviceAnchorPersistenceANDROID</type> <name>handle</name></param> + <param>const <type>XrPersistedAnchorSpaceInfoANDROID</type>* <name>persistedInfo</name></param> + <param><type>XrUuidEXT</type>* <name>anchorIdOutput</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ANCHOR_ID_NOT_FOUND_ANDROID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PERSISTED_DATA_NOT_READY_ANDROID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetAnchorPersistStateANDROID</name></proto> + <param><type>XrDeviceAnchorPersistenceANDROID</type> <name>handle</name></param> + <param>const <type>XrUuidEXT</type>* <name>anchorId</name></param> + <param><type>XrAnchorPersistStateANDROID</type>* <name>persistState</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ANCHOR_ID_NOT_FOUND_ANDROID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERSISTED_DATA_NOT_READY_ANDROID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreatePersistedAnchorSpaceANDROID</name></proto> + <param><type>XrDeviceAnchorPersistenceANDROID</type> <name>handle</name></param> + <param>const <type>XrPersistedAnchorSpaceCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>anchorOutput</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PERSISTED_DATA_NOT_READY_ANDROID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumeratePersistedAnchorsANDROID</name></proto> + <param><type>XrDeviceAnchorPersistenceANDROID</type> <name>handle</name></param> + <param optional="true"><type>uint32_t</type> <name>anchorIdCapacityInput</name></param> + <param><type>uint32_t</type>* <name>anchorIdCountOutput</name></param> + <param optional="true" len="anchorIdCapacityInput"><type>XrUuidEXT</type>* <name>anchorIds</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ANCHOR_ID_NOT_FOUND_ANDROID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERSISTED_DATA_NOT_READY_ANDROID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUnpersistAnchorANDROID</name></proto> + <param><type>XrDeviceAnchorPersistenceANDROID</type> <name>handle</name></param> + <param>const <type>XrUuidEXT</type>* <name>anchorId</name></param> + </command> + + <!-- commands for XR_ANDROID_performance_metrics --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumeratePerformanceMetricsCounterPathsANDROID</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param optional="true"><type>uint32_t</type> <name>counterPathCapacityInput</name></param> + <param><type>uint32_t</type>* <name>counterPathCountOutput</name></param> + <param optional="true" len="counterPathCapacityInput"><type>XrPath</type>* <name>counterPaths</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetPerformanceMetricsStateANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrPerformanceMetricsStateANDROID</type>* <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetPerformanceMetricsStateANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPerformanceMetricsStateANDROID</type>* <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrQueryPerformanceMetricsCounterANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrPath</type> <name>counterPath</name></param> + <param><type>XrPerformanceMetricsCounterANDROID</type>* <name>counter</name></param> + </command> + + <!-- XR_ANDROID_trackables_qr_code --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_MISMATCHING_TRACKABLE_TYPE_ANDROID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetTrackableQrCodeANDROID</name></proto> + <param><type>XrTrackableTrackerANDROID</type> <name>tracker</name></param> + <param>const <type>XrTrackableGetInfoANDROID</type>* <name>getInfo</name></param> + <param><type>XrTrackableQrCodeANDROID</type>* <name>qrCodeOutput</name></param> + </command> + + <!-- commands for XR_ANDROID_composition_layer_passthrough_mesh --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_MESH_DATA_LIMIT_EXCEEDED_ANDROID,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreatePassthroughLayerANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrPassthroughLayerCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrPassthroughLayerANDROID</type>* <name>layer</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyPassthroughLayerANDROID</name></proto> + <param externsync="true_with_children"><type>XrPassthroughLayerANDROID</type> <name>layer</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_MESH_DATA_LIMIT_EXCEEDED_ANDROID,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetPassthroughLayerMeshANDROID</name></proto> + <param><type>XrPassthroughLayerANDROID</type> <name>layer</name></param> + <param>const <type>XrPassthroughLayerMeshANDROID</type>* <name>mesh</name></param> + </command> + + <!-- XR_ANDROID_scene_meshing --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSupportedSemanticLabelSetsANDROID</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param optional="true"><type>uint32_t</type> <name>supportedSemanticLabelSetsInputCapacity</name></param> + <param><type>uint32_t</type>* <name>supportedSemanticLabelSetsOutputCount</name></param> + <param optional="true" len="supportedSemanticLabelSetsInputCapacity"><type>XrSceneMeshSemanticLabelSetANDROID</type>* <name>supportedSemanticLabelSets</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSceneMeshingTrackerANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSceneMeshingTrackerCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrSceneMeshingTrackerANDROID</type>* <name>tracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySceneMeshingTrackerANDROID</name></proto> + <param externsync="true_with_children"><type>XrSceneMeshingTrackerANDROID</type> <name>tracker</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID"> + <proto><type>XrResult</type> <name>xrCreateSceneMeshSnapshotANDROID</name></proto> + <param><type>XrSceneMeshingTrackerANDROID</type> <name>tracker</name></param> + <param>const <type>XrSceneMeshSnapshotCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrSceneMeshSnapshotCreationResultANDROID</type>* <name>outSnapshotCreationResult</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySceneMeshSnapshotANDROID</name></proto> + <param externsync="true_with_children"><type>XrSceneMeshSnapshotANDROID</type> <name>snapshot</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetAllSubmeshStatesANDROID</name></proto> + <param><type>XrSceneMeshSnapshotANDROID</type> <name>snapshot</name></param> + <param optional="true"><type>uint32_t</type> <name>submeshStateCapacityInput</name></param> + <param><type>uint32_t</type>* <name>submeshStateCountOutput</name></param> + <param optional="true" len="submeshStateCapacityInput"><type>XrSceneSubmeshStateANDROID</type>* <name>submeshStates</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSubmeshDataANDROID</name></proto> + <param><type>XrSceneMeshSnapshotANDROID</type> <name>snapshot</name></param> + <param><type>uint32_t</type> <name>submeshDataCount</name></param> + <param len="submeshDataCount"><type>XrSceneSubmeshDataANDROID</type>* <name>inoutSubmeshData</name></param> + </command> + + <!-- commands for XR_ANDROID_eye_tracking --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateEyeTrackerANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrEyeTrackerCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrEyeTrackerANDROID</type>* <name>eyeTracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyEyeTrackerANDROID</name></proto> + <param externsync="true_with_children"><type>XrEyeTrackerANDROID</type> <name>eyeTracker</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetCoarseTrackingEyesInfoANDROID</name></proto> + <param><type>XrEyeTrackerANDROID</type> <name>eyeTracker</name></param> + <param>const <type>XrEyesGetInfoANDROID</type>* <name>getInfo</name></param> + <param><type>XrEyesANDROID</type>* <name>eyesOutput</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetFineTrackingEyesInfoANDROID</name></proto> + <param><type>XrEyeTrackerANDROID</type> <name>eyeTracker</name></param> + <param>const <type>XrEyesGetInfoANDROID</type>* <name>getInfo</name></param> + <param><type>XrEyesANDROID</type>* <name>eyesOutput</name></param> + </command> + + <!-- commands for XR_ANDROID_light_estimation --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST"> + <proto><type>XrResult</type> <name>xrCreateLightEstimatorANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrLightEstimatorCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrLightEstimatorANDROID</type>* <name>outHandle</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyLightEstimatorANDROID</name></proto> + <param externsync="true_with_children"><type>XrLightEstimatorANDROID</type> <name>estimator</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetLightEstimateANDROID</name></proto> + <param><type>XrLightEstimatorANDROID</type> <name>estimator</name></param> + <param>const <type>XrLightEstimateGetInfoANDROID</type>* <name>input</name></param> + <param><type>XrLightEstimateANDROID</type>* <name>output</name></param> + </command> + + <!-- XR_EXT_plane_detection --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PLANE_DETECTION_PERMISSION_DENIED_EXT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreatePlaneDetectorEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrPlaneDetectorCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrPlaneDetectorEXT</type>* <name>planeDetector</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyPlaneDetectorEXT</name></proto> + <param externsync="true_with_children"><type>XrPlaneDetectorEXT</type> <name>planeDetector</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPACE_NOT_LOCATABLE_EXT,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrBeginPlaneDetectionEXT</name></proto> + <param><type>XrPlaneDetectorEXT</type> <name>planeDetector</name></param> + <param>const <type>XrPlaneDetectorBeginInfoEXT</type>* <name>beginInfo</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetPlaneDetectionStateEXT</name></proto> + <param><type>XrPlaneDetectorEXT</type> <name>planeDetector</name></param> + <param><type>XrPlaneDetectionStateEXT</type>* <name>state</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPACE_NOT_LOCATABLE_EXT,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetPlaneDetectionsEXT</name></proto> + <param><type>XrPlaneDetectorEXT</type> <name>planeDetector</name></param> + <param>const <type>XrPlaneDetectorGetInfoEXT</type>* <name>info</name></param> + <param><type>XrPlaneDetectorLocationsEXT</type>* <name>locations</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetPlanePolygonBufferEXT</name></proto> + <param><type>XrPlaneDetectorEXT</type> <name>planeDetector</name></param> + <param><type>uint64_t</type> <name>planeId</name></param> + <param><type>uint32_t</type> <name>polygonBufferIndex</name></param> + <param><type>XrPlaneDetectorPolygonBufferEXT</type>* <name>polygonBuffer</name></param> + </command> + + <!-- commands for XR_META_virtual_keyboard --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateVirtualKeyboardMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrVirtualKeyboardCreateInfoMETA</type>* <name>createInfo</name></param> + <param><type>XrVirtualKeyboardMETA</type>* <name>keyboard</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyVirtualKeyboardMETA</name></proto> + <param externsync="true_with_children"><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateVirtualKeyboardSpaceMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></param> + <param>const <type>XrVirtualKeyboardSpaceCreateInfoMETA</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>keyboardSpace</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSuggestVirtualKeyboardLocationMETA</name></proto> + <param><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></param> + <param>const <type>XrVirtualKeyboardLocationInfoMETA</type>* <name>locationInfo</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetVirtualKeyboardScaleMETA</name></proto> + <param><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></param> + <param><type>float</type>* <name>scale</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetVirtualKeyboardModelVisibilityMETA</name></proto> + <param><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></param> + <param>const <type>XrVirtualKeyboardModelVisibilitySetInfoMETA</type>* <name>modelVisibility</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetVirtualKeyboardModelAnimationStatesMETA</name></proto> + <param><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></param> + <param><type>XrVirtualKeyboardModelAnimationStatesMETA</type>* <name>animationStates</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetVirtualKeyboardDirtyTexturesMETA</name></proto> + <param><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></param> + <param optional="true"><type>uint32_t</type> <name>textureIdCapacityInput</name></param> + <param><type>uint32_t</type>* <name>textureIdCountOutput</name></param> + <param optional="true" len="textureIdCapacityInput"><type>uint64_t</type>* <name>textureIds</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetVirtualKeyboardTextureDataMETA</name></proto> + <param><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></param> + <param><type>uint64_t</type> <name>textureId</name></param> + <param><type>XrVirtualKeyboardTextureDataMETA</type>* <name>textureData</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSendVirtualKeyboardInputMETA</name></proto> + <param><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></param> + <param>const <type>XrVirtualKeyboardInputInfoMETA</type>* <name>info</name></param> + <param><type>XrPosef</type>* <name>interactorRootPose</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrChangeVirtualKeyboardTextContextMETA</name></proto> + <param><type>XrVirtualKeyboardMETA</type> <name>keyboard</name></param> + <param>const <type>XrVirtualKeyboardTextContextChangeInfoMETA</type>* <name>changeInfo</name></param> + </command> + + <!-- XR_ML_user_calibration --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnableUserCalibrationEventsML</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrUserCalibrationEnableEventsInfoML</type>* <name>enableInfo</name></param> + </command> + + <!-- XR_ML_localization_map --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LOCALIZATION_MAP_PERMISSION_DENIED_ML,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnableLocalizationEventsML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrLocalizationEnableEventsInfoML</type> * <name>info</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LOCALIZATION_MAP_PERMISSION_DENIED_ML,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrQueryLocalizationMapsML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true">const <type>XrLocalizationMapQueryInfoBaseHeaderML</type>* <name>queryInfo</name></param> + <param optional="true"><type>uint32_t</type> <name>mapCapacityInput</name></param> + <param><type>uint32_t</type> * <name>mapCountOutput</name></param> + <param optional="true" len="mapCapacityInput"><type>XrLocalizationMapML</type>* <name>maps</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LOCALIZATION_MAP_FAIL_ML,XR_ERROR_LOCALIZATION_MAP_PERMISSION_DENIED_ML,XR_ERROR_LOCALIZATION_MAP_UNAVAILABLE_ML,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRequestMapLocalizationML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrMapLocalizationRequestInfoML</type>* <name>requestInfo</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LOCALIZATION_MAP_ALREADY_EXISTS_ML,XR_ERROR_LOCALIZATION_MAP_IMPORT_EXPORT_PERMISSION_DENIED_ML,XR_ERROR_LOCALIZATION_MAP_INCOMPATIBLE_ML,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrImportLocalizationMapML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrLocalizationMapImportInfoML</type>* <name>importInfo</name></param> + <param optional="true"><type>XrUuidEXT</type>* <name>mapUuid</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_LOCALIZATION_MAP_CANNOT_EXPORT_CLOUD_MAP_ML,XR_ERROR_LOCALIZATION_MAP_IMPORT_EXPORT_PERMISSION_DENIED_ML,XR_ERROR_LOCALIZATION_MAP_UNAVAILABLE_ML,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateExportedLocalizationMapML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrUuidEXT</type>* <name>mapUuid</name></param> + <param><type>XrExportedLocalizationMapML</type>* <name>map</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyExportedLocalizationMapML</name></proto> + <param externsync="true_with_children"><type>XrExportedLocalizationMapML</type> <name>map</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetExportedLocalizationMapDataML</name></proto> + <param><type>XrExportedLocalizationMapML</type> <name>map</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>char</type>* <name>buffer</name></param> + </command> + + <!-- commands for XR_ML_marker_understanding --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_MARKER_DETECTOR_INVALID_CREATE_INFO_ML,XR_ERROR_MARKER_DETECTOR_PERMISSION_DENIED_ML,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateMarkerDetectorML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrMarkerDetectorCreateInfoML</type>* <name>createInfo</name></param> + <param><type>XrMarkerDetectorML</type>* <name>markerDetector</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyMarkerDetectorML</name></proto> + <param externsync="true_with_children"><type>XrMarkerDetectorML</type> <name>markerDetector</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSnapshotMarkerDetectorML</name></proto> + <param><type>XrMarkerDetectorML</type> <name>markerDetector</name></param> + <param><type>XrMarkerDetectorSnapshotInfoML</type>* <name>snapshotInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetMarkerDetectorStateML</name></proto> + <param><type>XrMarkerDetectorML</type> <name>markerDetector</name></param> + <param><type>XrMarkerDetectorStateML</type>* <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetMarkersML</name></proto> + <param><type>XrMarkerDetectorML</type> <name>markerDetector</name></param> + <param optional="true"><type>uint32_t</type> <name>markerCapacityInput</name></param> + <param><type>uint32_t</type>* <name>markerCountOutput</name></param> + <param optional="true" len="markerCapacityInput"><type>XrMarkerML</type>* <name>markers</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_MARKER_INVALID_ML,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetMarkerReprojectionErrorML</name></proto> + <param><type>XrMarkerDetectorML</type> <name>markerDetector</name></param> + <param><type>XrMarkerML</type> <name>marker</name></param> + <param><type>float</type>* <name>reprojectionErrorMeters</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_MARKER_INVALID_ML,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetMarkerLengthML</name></proto> + <param><type>XrMarkerDetectorML</type> <name>markerDetector</name></param> + <param><type>XrMarkerML</type> <name>marker</name></param> + <param><type>float</type>* <name>meters</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_MARKER_DETECTOR_INVALID_DATA_QUERY_ML,XR_ERROR_MARKER_INVALID_ML,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetMarkerNumberML</name></proto> + <param><type>XrMarkerDetectorML</type> <name>markerDetector</name></param> + <param><type>XrMarkerML</type> <name>marker</name></param> + <param><type>uint64_t</type>* <name>number</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_MARKER_DETECTOR_INVALID_DATA_QUERY_ML,XR_ERROR_MARKER_INVALID_ML,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetMarkerStringML</name></proto> + <param><type>XrMarkerDetectorML</type> <name>markerDetector</name></param> + <param><type>XrMarkerML</type> <name>marker</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>char</type>* <name>buffer</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_MARKER_DETECTOR_LOCATE_FAILED_ML,XR_ERROR_MARKER_INVALID_ML,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateMarkerSpaceML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrMarkerSpaceCreateInfoML</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>space</name></param> + </command> + + <!-- XR_EXT_future --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPollFutureEXT</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrFuturePollInfoEXT</type>* <name>pollInfo</name></param> + <param><type>XrFuturePollResultEXT</type>* <name>pollResult</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCancelFutureEXT</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param externsync="cancelInfo.future">const <type>XrFutureCancelInfoEXT</type>* <name>cancelInfo</name></param> + </command> + + + <!-- XR_META_environment_depth --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_NOT_PERMITTED_PASSTHROUGH_FB,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateEnvironmentDepthProviderMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrEnvironmentDepthProviderCreateInfoMETA</type>* <name>createInfo</name></param> + <param><type>XrEnvironmentDepthProviderMETA</type>* <name>environmentDepthProvider</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyEnvironmentDepthProviderMETA</name></proto> + <param externsync="true_with_children"><type>XrEnvironmentDepthProviderMETA</type> <name>environmentDepthProvider</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_UNEXPECTED_STATE_PASSTHROUGH_FB"> + <proto><type>XrResult</type> <name>xrStartEnvironmentDepthProviderMETA</name></proto> + <param><type>XrEnvironmentDepthProviderMETA</type> <name>environmentDepthProvider</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_UNEXPECTED_STATE_PASSTHROUGH_FB"> + <proto><type>XrResult</type> <name>xrStopEnvironmentDepthProviderMETA</name></proto> + <param><type>XrEnvironmentDepthProviderMETA</type> <name>environmentDepthProvider</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateEnvironmentDepthSwapchainMETA</name></proto> + <param><type>XrEnvironmentDepthProviderMETA</type> <name>environmentDepthProvider</name></param> + <param>const <type>XrEnvironmentDepthSwapchainCreateInfoMETA</type>* <name>createInfo</name></param> + <param><type>XrEnvironmentDepthSwapchainMETA</type>* <name>swapchain</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyEnvironmentDepthSwapchainMETA</name></proto> + <param externsync="true_with_children"><type>XrEnvironmentDepthSwapchainMETA</type> <name>swapchain</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateEnvironmentDepthSwapchainImagesMETA</name></proto> + <param><type>XrEnvironmentDepthSwapchainMETA</type> <name>swapchain</name></param> + <param optional="true"><type>uint32_t</type> <name>imageCapacityInput</name></param> + <param><type>uint32_t</type>* <name>imageCountOutput</name></param> + <param optional="true" len="imageCapacityInput"><type>XrSwapchainImageBaseHeader</type>* <name>images</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetEnvironmentDepthSwapchainStateMETA</name></proto> + <param><type>XrEnvironmentDepthSwapchainMETA</type> <name>swapchain</name></param> + <param><type>XrEnvironmentDepthSwapchainStateMETA</type>* <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_ENVIRONMENT_DEPTH_NOT_AVAILABLE_META,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrAcquireEnvironmentDepthImageMETA</name></proto> + <param><type>XrEnvironmentDepthProviderMETA</type> <name>environmentDepthProvider</name></param> + <param>const <type>XrEnvironmentDepthImageAcquireInfoMETA</type>* <name>acquireInfo</name></param> + <param><type>XrEnvironmentDepthImageMETA</type>* <name>environmentDepthImage</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetEnvironmentDepthHandRemovalMETA</name></proto> + <param><type>XrEnvironmentDepthProviderMETA</type> <name>environmentDepthProvider</name></param> + <param>const <type>XrEnvironmentDepthHandRemovalSetInfoMETA</type>* <name>setInfo</name></param> + </command> + + <!-- XR_EXT_stationary_reference_space --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetStationaryReferenceSpaceGenerationIdEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true">const <type>XrStationaryReferenceSpaceGenerationIdGetInfoEXT</type>* <name>getInfo</name></param> + <param><type>XrStationaryReferenceSpaceGenerationIdResultEXT</type>* <name>generationIdResult</name></param> + </command> + + <!-- XR_ML_facial_expression --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FACIAL_EXPRESSION_PERMISSION_DENIED_ML,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateFacialExpressionClientML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrFacialExpressionClientCreateInfoML</type>* <name>createInfo</name></param> + <param><type>XrFacialExpressionClientML</type>* <name>facialExpressionClient</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyFacialExpressionClientML</name></proto> + <param externsync="true_with_children"><type>XrFacialExpressionClientML</type> <name>facialExpressionClient</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetFacialExpressionBlendShapePropertiesML</name></proto> + <param><type>XrFacialExpressionClientML</type> <name>facialExpressionClient</name></param> + <param>const <type>XrFacialExpressionBlendShapeGetInfoML</type>* <name>blendShapeGetInfo</name></param> + <param><type>uint32_t</type> <name>blendShapeCount</name></param> + <param len="blendShapeCount"><type>XrFacialExpressionBlendShapePropertiesML</type>* <name>blendShapes</name></param> + </command> + + <!-- XR_KHR_locate_spaces --> + <command name="xrLocateSpacesKHR" alias="xrLocateSpaces"/> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrLocateSpaces</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpacesLocateInfo</type>* <name>locateInfo</name></param> + <param><type>XrSpaceLocations</type>* <name>spaceLocations</name></param> + </command> + + <!-- XR_EXT_spatial_entity --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSpatialCapabilitiesEXT</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param optional="true"><type>uint32_t</type> <name>capabilityCapacityInput</name></param> + <param><type>uint32_t</type>* <name>capabilityCountOutput</name></param> + <param optional="true" len="capabilityCapacityInput"><type>XrSpatialCapabilityEXT</type>* <name>capabilities</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSpatialCapabilityComponentTypesEXT</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrSpatialCapabilityEXT</type> <name>capability</name></param> + <param><type>XrSpatialCapabilityComponentTypesEXT</type>* <name>capabilityComponents</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSpatialCapabilityFeaturesEXT</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrSpatialCapabilityEXT</type> <name>capability</name></param> + <param optional="true"><type>uint32_t</type> <name>capabilityFeatureCapacityInput</name></param> + <param><type>uint32_t</type>* <name>capabilityFeatureCountOutput</name></param> + <param optional="true" len="capabilityFeatureCapacityInput"><type>XrSpatialCapabilityFeatureEXT</type>* <name>capabilityFeatures</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT,XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT,XR_ERROR_SPATIAL_COMPONENT_UNSUPPORTED_FOR_CAPABILITY_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialContextAsyncEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialContextCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialContextCompleteEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrCreateSpatialContextCompletionEXT</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpatialContextEXT</name></proto> + <param externsync="true_with_children"><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_COMPONENT_NOT_ENABLED_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialDiscoverySnapshotAsyncEXT</name></proto> + <param><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + <param>const <type>XrSpatialDiscoverySnapshotCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialDiscoverySnapshotCompleteEXT</name></proto> + <param><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + <param>const <type>XrCreateSpatialDiscoverySnapshotCompletionInfoEXT</type>* <name>createSnapshotCompletionInfo</name></param> + <param><type>XrCreateSpatialDiscoverySnapshotCompletionEXT</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrQuerySpatialComponentDataEXT</name></proto> + <param><type>XrSpatialSnapshotEXT</type> <name>snapshot</name></param> + <param>const <type>XrSpatialComponentDataQueryConditionEXT</type>* <name>queryCondition</name></param> + <param><type>XrSpatialComponentDataQueryResultEXT</type>* <name>queryResult</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpatialSnapshotEXT</name></proto> + <param externsync="true_with_children"><type>XrSpatialSnapshotEXT</type> <name>snapshot</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_ENTITY_ID_INVALID_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialEntityFromIdEXT</name></proto> + <param><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + <param>const <type>XrSpatialEntityFromIdCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrSpatialEntityEXT</type>* <name>spatialEntity</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpatialEntityEXT</name></proto> + <param externsync="true_with_children"><type>XrSpatialEntityEXT</type> <name>spatialEntity</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_COMPONENT_NOT_ENABLED_EXT,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialUpdateSnapshotEXT</name></proto> + <param><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + <param>const <type>XrSpatialUpdateSnapshotCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrSpatialSnapshotEXT</type>* <name>snapshot</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialBufferStringEXT</name></proto> + <param><type>XrSpatialSnapshotEXT</type> <name>snapshot</name></param> + <param>const <type>XrSpatialBufferGetInfoEXT</type>* <name>info</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>char</type>* <name>buffer</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialBufferUint8EXT</name></proto> + <param><type>XrSpatialSnapshotEXT</type> <name>snapshot</name></param> + <param>const <type>XrSpatialBufferGetInfoEXT</type>* <name>info</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>uint8_t</type>* <name>buffer</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialBufferUint16EXT</name></proto> + <param><type>XrSpatialSnapshotEXT</type> <name>snapshot</name></param> + <param>const <type>XrSpatialBufferGetInfoEXT</type>* <name>info</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>uint16_t</type>* <name>buffer</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialBufferUint32EXT</name></proto> + <param><type>XrSpatialSnapshotEXT</type> <name>snapshot</name></param> + <param>const <type>XrSpatialBufferGetInfoEXT</type>* <name>info</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>uint32_t</type>* <name>buffer</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialBufferFloatEXT</name></proto> + <param><type>XrSpatialSnapshotEXT</type> <name>snapshot</name></param> + <param>const <type>XrSpatialBufferGetInfoEXT</type>* <name>info</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>float</type>* <name>buffer</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialBufferVector2fEXT</name></proto> + <param><type>XrSpatialSnapshotEXT</type> <name>snapshot</name></param> + <param>const <type>XrSpatialBufferGetInfoEXT</type>* <name>info</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>XrVector2f</type>* <name>buffer</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialBufferVector3fEXT</name></proto> + <param><type>XrSpatialSnapshotEXT</type> <name>snapshot</name></param> + <param>const <type>XrSpatialBufferGetInfoEXT</type>* <name>info</name></param> + <param optional="true"><type>uint32_t</type> <name>bufferCapacityInput</name></param> + <param><type>uint32_t</type>* <name>bufferCountOutput</name></param> + <param optional="true" len="bufferCapacityInput"><type>XrVector3f</type>* <name>buffer</name></param> + </command> + + <!-- XR_EXT_spatial_anchor --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorEXT</name></proto> + <param><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + <param>const <type>XrSpatialAnchorCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrSpatialEntityIdEXT</type>* <name>anchorEntityId</name></param> + <param><type>XrSpatialEntityEXT</type>* <name>anchorEntity</name></param> + </command> + + <!-- XR_EXT_spatial_persistence --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSpatialPersistenceScopesEXT</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param optional="true"><type>uint32_t</type> <name>persistenceScopeCapacityInput</name></param> + <param><type>uint32_t</type>* <name>persistenceScopeCountOutput</name></param> + <param optional="true" len="persistenceScopeCapacityInput"><type>XrSpatialPersistenceScopeEXT</type>* <name>persistenceScopes</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_PERSISTENCE_SCOPE_UNSUPPORTED_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialPersistenceContextAsyncEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialPersistenceContextCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialPersistenceContextCompleteEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrCreateSpatialPersistenceContextCompletionEXT</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpatialPersistenceContextEXT</name></proto> + <param externsync="true_with_children"><type>XrSpatialPersistenceContextEXT</type> <name>persistenceContext</name></param> + </command> + + <!-- XR_EXT_spatial_persistence_operations --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_ENTITY_ID_INVALID_EXT,XR_ERROR_SPATIAL_PERSISTENCE_SCOPE_INCOMPATIBLE_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPersistSpatialEntityAsyncEXT</name></proto> + <param><type>XrSpatialPersistenceContextEXT</type> <name>persistenceContext</name></param> + <param>const <type>XrSpatialEntityPersistInfoEXT</type>* <name>persistInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPersistSpatialEntityCompleteEXT</name></proto> + <param><type>XrSpatialPersistenceContextEXT</type> <name>persistenceContext</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrPersistSpatialEntityCompletionEXT</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUnpersistSpatialEntityAsyncEXT</name></proto> + <param><type>XrSpatialPersistenceContextEXT</type> <name>persistenceContext</name></param> + <param>const <type>XrSpatialEntityUnpersistInfoEXT</type>* <name>unpersistInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUnpersistSpatialEntityCompleteEXT</name></proto> + <param><type>XrSpatialPersistenceContextEXT</type> <name>persistenceContext</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrUnpersistSpatialEntityCompletionEXT</type>* <name>completion</name></param> + </command> + + <!-- XR_ML_system_notifications --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SYSTEM_NOTIFICATION_INCOMPATIBLE_SKU_ML,XR_ERROR_SYSTEM_NOTIFICATION_PERMISSION_DENIED_ML,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetSystemNotificationsML</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrSystemNotificationsSetInfoML</type>* <name>info</name></param> + </command> + + <!-- XR_ML_spatial_anchors --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_ANCHORS_PERMISSION_DENIED_ML,XR_ERROR_SPATIAL_ANCHORS_SPACE_NOT_LOCATABLE_ML,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorsAsyncML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialAnchorsCreateInfoBaseHeaderML</type>* <name>createInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorsCompleteML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrCreateSpatialAnchorsCompletionML</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialAnchorStateML</name></proto> + <param><type>XrSpace</type> <name>anchor</name></param> + <param><type>XrSpatialAnchorStateML</type>* <name>state</name></param> + </command> + + <!-- XR_ML_spatial_anchors_storage --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_ANCHORS_PERMISSION_DENIED_ML,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorsStorageML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialAnchorsCreateStorageInfoML</type>* <name>createInfo</name></param> + <param><type>XrSpatialAnchorsStorageML</type>* <name>storage</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpatialAnchorsStorageML</name></proto> + <param externsync="true_with_children"><type>XrSpatialAnchorsStorageML</type> <name>storage</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_ANCHORS_SPACE_NOT_LOCATABLE_ML,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrQuerySpatialAnchorsAsyncML</name></proto> + <param><type>XrSpatialAnchorsStorageML</type> <name>storage</name></param> + <param>const <type>XrSpatialAnchorsQueryInfoBaseHeaderML</type>* <name>queryInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrQuerySpatialAnchorsCompleteML</name></proto> + <param><type>XrSpatialAnchorsStorageML</type> <name>storage</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrSpatialAnchorsQueryCompletionML</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPublishSpatialAnchorsAsyncML</name></proto> + <param><type>XrSpatialAnchorsStorageML</type> <name>storage</name></param> + <param>const <type>XrSpatialAnchorsPublishInfoML</type>* <name>publishInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPublishSpatialAnchorsCompleteML</name></proto> + <param><type>XrSpatialAnchorsStorageML</type> <name>storage</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrSpatialAnchorsPublishCompletionML</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrDeleteSpatialAnchorsAsyncML</name></proto> + <param><type>XrSpatialAnchorsStorageML</type> <name>storage</name></param> + <param>const <type>XrSpatialAnchorsDeleteInfoML</type>* <name>deleteInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrDeleteSpatialAnchorsCompleteML</name></proto> + <param><type>XrSpatialAnchorsStorageML</type> <name>storage</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrSpatialAnchorsDeleteCompletionML</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUpdateSpatialAnchorsExpirationAsyncML</name></proto> + <param><type>XrSpatialAnchorsStorageML</type> <name>storage</name></param> + <param>const <type>XrSpatialAnchorsUpdateExpirationInfoML</type>* <name>updateInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUpdateSpatialAnchorsExpirationCompleteML</name></proto> + <param><type>XrSpatialAnchorsStorageML</type> <name>storage</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrSpatialAnchorsUpdateExpirationCompletionML</type>* <name>completion</name></param> + </command> + + <!-- XR_ML_world_mesh_detection --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_WORLD_MESH_DETECTOR_PERMISSION_DENIED_ML"> + <proto><type>XrResult</type> <name>xrCreateWorldMeshDetectorML</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrWorldMeshDetectorCreateInfoML</type>* <name>createInfo</name></param> + <param><type>XrWorldMeshDetectorML</type>* <name>detector</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyWorldMeshDetectorML</name></proto> + <param externsync="true_with_children"><type>XrWorldMeshDetectorML</type> <name>detector</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_WORLD_MESH_DETECTOR_SPACE_NOT_LOCATABLE_ML"> + <proto><type>XrResult</type> <name>xrRequestWorldMeshStateAsyncML</name></proto> + <param><type>XrWorldMeshDetectorML</type> <name>detector</name></param> + <param>const <type>XrWorldMeshStateRequestInfoML</type>* <name>stateRequest</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRequestWorldMeshStateCompleteML</name></proto> + <param><type>XrWorldMeshDetectorML</type> <name>detector</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrWorldMeshStateRequestCompletionML</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetWorldMeshBufferRecommendSizeML</name></proto> + <param><type>XrWorldMeshDetectorML</type> <name>detector</name></param> + <param>const <type>XrWorldMeshBufferRecommendedSizeInfoML</type>* <name>sizeInfo</name></param> + <param><type>XrWorldMeshBufferSizeML</type>* <name>size</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrAllocateWorldMeshBufferML</name></proto> + <param><type>XrWorldMeshDetectorML</type> <name>detector</name></param> + <param>const <type>XrWorldMeshBufferSizeML</type>* <name>size</name></param> + <param><type>XrWorldMeshBufferML</type>* <name>buffer</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrFreeWorldMeshBufferML</name></proto> + <param><type>XrWorldMeshDetectorML</type> <name>detector</name></param> + <param>const <type>XrWorldMeshBufferML</type>* <name>buffer</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRequestWorldMeshAsyncML</name></proto> + <param><type>XrWorldMeshDetectorML</type> <name>detector</name></param> + <param>const <type>XrWorldMeshGetInfoML</type>* <name>getInfo</name></param> + <param><type>XrWorldMeshBufferML</type>* <name>buffer</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_WORLD_MESH_DETECTOR_SPACE_NOT_LOCATABLE_ML"> + <proto><type>XrResult</type> <name>xrRequestWorldMeshCompleteML</name></proto> + <param><type>XrWorldMeshDetectorML</type> <name>detector</name></param> + <param>const <type>XrWorldMeshRequestCompletionInfoML</type>* <name>completionInfo</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrWorldMeshRequestCompletionML</type>* <name>completion</name></param> + </command> + + <!-- XR_EXT_render_model --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RENDER_MODEL_ID_INVALID_EXT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateRenderModelEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrRenderModelCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrRenderModelEXT</type>* <name>renderModel</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyRenderModelEXT</name></proto> + <param externsync="true_with_children"><type>XrRenderModelEXT</type> <name>renderModel</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetRenderModelPropertiesEXT</name></proto> + <param><type>XrRenderModelEXT</type> <name>renderModel</name></param> + <param optional="true">const <type>XrRenderModelPropertiesGetInfoEXT</type>* <name>getInfo</name></param> + <param><type>XrRenderModelPropertiesEXT</type>* <name>properties</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateRenderModelSpaceEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrRenderModelSpaceCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>space</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RENDER_MODEL_ASSET_UNAVAILABLE_EXT,XR_ERROR_RENDER_MODEL_GLTF_EXTENSION_REQUIRED_EXT,XR_ERROR_RENDER_MODEL_ID_INVALID_EXT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateRenderModelAssetEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrRenderModelAssetCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrRenderModelAssetEXT</type>* <name>asset</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyRenderModelAssetEXT</name></proto> + <param externsync="true_with_children"><type>XrRenderModelAssetEXT</type> <name>asset</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetRenderModelAssetDataEXT</name></proto> + <param><type>XrRenderModelAssetEXT</type> <name>asset</name></param> + <param optional="true">const <type>XrRenderModelAssetDataGetInfoEXT</type>* <name>getInfo</name></param> + <param><type>XrRenderModelAssetDataEXT</type>* <name>buffer</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetRenderModelAssetPropertiesEXT</name></proto> + <param><type>XrRenderModelAssetEXT</type> <name>asset</name></param> + <param optional="true">const <type>XrRenderModelAssetPropertiesGetInfoEXT</type>* <name>getInfo</name></param> + <param><type>XrRenderModelAssetPropertiesEXT</type>* <name>properties</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetRenderModelStateEXT</name></proto> + <param><type>XrRenderModelEXT</type> <name>renderModel</name></param> + <param>const <type>XrRenderModelStateGetInfoEXT</type>* <name>getInfo</name></param> + <param><type>XrRenderModelStateEXT</type>* <name>state</name></param> + </command> + + <!-- XR_EXT_interaction_render_model --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateInteractionRenderModelIdsEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrInteractionRenderModelIdsEnumerateInfoEXT</type>* <name>getInfo</name></param> + <param optional="true"><type>uint32_t</type> <name>renderModelIdCapacityInput</name></param> + <param><type>uint32_t</type>* <name>renderModelIdCountOutput</name></param> + <param len="renderModelIdCapacityInput" optional="true"><type>XrRenderModelIdEXT</type>* <name>renderModelIds</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_NOT_INTERACTION_RENDER_MODEL_EXT,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateRenderModelSubactionPathsEXT</name></proto> + <param><type>XrRenderModelEXT</type> <name>renderModel</name></param> + <param optional="true">const <type>XrInteractionRenderModelSubactionPathInfoEXT</type>* <name>info</name></param> + <param optional="true"><type>uint32_t</type> <name>pathCapacityInput</name></param> + <param><type>uint32_t</type>* <name>pathCountOutput</name></param> + <param len="pathCapacityInput" optional="true"><type>XrPath</type>* <name>paths</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_NOT_INTERACTION_RENDER_MODEL_EXT,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RENDER_MODEL_ID_INVALID_EXT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetRenderModelPoseTopLevelUserPathEXT</name></proto> + <param><type>XrRenderModelEXT</type> <name>renderModel</name></param> + <param>const <type>XrInteractionRenderModelTopLevelUserPathGetInfoEXT</type>* <name>info</name></param> + <param><type>XrPath</type>* <name>topLevelUserPath</name></param> + </command> + + <!-- XR_BD_spatial_audio_rendering --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSupportedAudioSampleRateBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true"><type>uint32_t</type> <name>sampleRateCapacityInput</name></param> + <param><type>uint32_t</type>* <name>sampleRateCountOutput</name></param> + <param len="sampleRateCapacityInput" optional="true"><type>XrAudioSampleRateBD</type>* <name>sampleRates</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrQueryFramesPerBufferRangeBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrAudioSampleRateBD</type> <name>sampleRate</name></param> + <param><type>uint32_t</type>* <name>min</name></param> + <param><type>uint32_t</type>* <name>max</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAudioRendererBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialAudioRendererCreateInfoBD</type>* <name>createInfo</name></param> + <param><type>XrSpatialAudioRendererBD</type>* <name>renderer</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpatialAudioRendererBD</name></proto> + <param externsync="true_with_children"><type>XrSpatialAudioRendererBD</type> <name>renderer</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSoundObstacleMaterialBD</name></proto> + <param><type>XrSpatialAudioRendererBD</type> <name>renderer</name></param> + <param>const <type>XrSoundObstacleMaterialConfigBD</type>* <name>config</name></param> + <param><type>XrSoundObstacleMaterialBD</type>* <name>material</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUpdateSoundObstacleMaterialConfigBD</name></proto> + <param><type>XrSoundObstacleMaterialBD</type> <name>material</name></param> + <param>const <type>XrSoundObstacleMaterialConfigBD</type>* <name>config</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySoundObstacleMaterialBD</name></proto> + <param externsync="true_with_children"><type>XrSoundObstacleMaterialBD</type> <name>material</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSoundObstacleBD</name></proto> + <param><type>XrSpatialAudioRendererBD</type> <name>renderer</name></param> + <param>const <type>XrSoundObstacleConfigBD</type>* <name>config</name></param> + <param>const <type>XrSoundTriangleMeshBD</type>* <name>mesh</name></param> + <param><type>XrSoundObstacleBD</type>* <name>soundObstacle</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUpdateSoundObstacleConfigBD</name></proto> + <param><type>XrSoundObstacleBD</type> <name>soundObstacle</name></param> + <param optional="true">const <type>XrSoundObstacleConfigBD</type>* <name>config</name></param> + <param optional="true">const <type>XrSoundTriangleMeshBD</type>* <name>mesh</name></param> + <param><type>XrSoundObstacleFlagsBD</type> <name>flags</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySoundObstacleBD</name></proto> + <param externsync="true_with_children"><type>XrSoundObstacleBD</type> <name>soundObstacle</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSoundObjectBD</name></proto> + <param><type>XrSpatialAudioRendererBD</type> <name>renderer</name></param> + <param>const <type>XrSoundObjectConfigBD</type>* <name>config</name></param> + <param><type>XrSoundObjectBD</type>* <name>soundObject</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUpdateSoundObjectConfigBD</name></proto> + <param><type>XrSoundObjectBD</type> <name>soundObject</name></param> + <param>const <type>XrSoundObjectConfigBD</type>* <name>config</name></param> + <param><type>XrSoundObjectFlagsBD</type> <name>flags</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSubmitSoundObjectBufferBD</name></proto> + <param><type>XrSoundObjectBD</type> <name>soundObject</name></param> + <param>const <type>XrAudioBufferBD</type>* <name>buffer</name></param> + <implicitexternsyncparams> + <param>pname:soundObject parameter by any other flink:xrSubmitSoundObjectBufferBD call, as well as the pname:renderer parameter by any other flink:xrWaitAudioPeriodBD or flink:xrEndAudioPeriodBD call (if the pname:renderer is the parent of pname:soundObject)</param> + </implicitexternsyncparams> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySoundObjectBD</name></proto> + <param externsync="true_with_children"><type>XrSoundObjectBD</type> <name>soundObject</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSoundFieldBD</name></proto> + <param><type>XrSpatialAudioRendererBD</type> <name>renderer</name></param> + <param>const <type>XrSoundFieldConfigBD</type>* <name>config</name></param> + <param><type>XrSoundFieldBD</type>* <name>soundField</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUpdateSoundFieldConfigBD</name></proto> + <param><type>XrSoundFieldBD</type> <name>soundField</name></param> + <param optional="true">const <type>XrSoundFieldConfigBD</type>* <name>config</name></param> + <param><type>XrSoundFieldFlagsBD</type> <name>flags</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSubmitSoundFieldBufferBD</name></proto> + <param><type>XrSoundFieldBD</type> <name>soundField</name></param> + <param>const <type>XrAudioBufferBD</type>* <name>buffer</name></param> + <implicitexternsyncparams> + <param>pname:soundField parameter by any other flink:xrSubmitSoundFieldBufferBD call, as well as the pname:renderer parameter by any other flink:xrWaitAudioPeriodBD or flink:xrEndAudioPeriodBD call (if the pname:renderer is the parent of pname:soundField)</param> + </implicitexternsyncparams> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySoundFieldBD</name></proto> + <param externsync="true_with_children"><type>XrSoundFieldBD</type> <name>soundField</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING,XR_TIMEOUT_EXPIRED" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST"> + <proto><type>XrResult</type> <name>xrWaitAudioPeriodBD</name></proto> + <param><type>XrSpatialAudioRendererBD</type> <name>renderer</name></param> + <param><type>XrDuration</type> <name>timeout</name></param> + <implicitexternsyncparams> + <param>the pname:renderer parameter by any other flink:xrWaitAudioPeriodBD or flink:xrEndAudioPeriodBD call, pname:soundField parameter by any other flink:xrSubmitSoundFieldBufferBD call (if the pname:soundField is a child of the pname:renderer), and pname:soundObject parameter by any other flink:xrSubmitSoundObjectBufferBD call (if the pname:soundObject is a child of the pname:renderer)</param> + </implicitexternsyncparams> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST"> + <proto><type>XrResult</type> <name>xrEndAudioPeriodBD</name></proto> + <param><type>XrSpatialAudioRendererBD</type> <name>renderer</name></param> + <implicitexternsyncparams> + <param>the pname:renderer parameter by any other flink:xrWaitAudioPeriodBD or flink:xrEndAudioPeriodBD call, pname:soundField parameter by any other flink:xrSubmitSoundFieldBufferBD call (if the pname:soundField is a child of the pname:renderer), and pname:soundObject parameter by any other flink:xrSubmitSoundObjectBufferBD call (if the pname:soundObject is a child of the pname:renderer)</param> + </implicitexternsyncparams> + </command> + + <!-- commands for XR_BD_spatial_sensing --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_ENTITY_ID_INVALID_BD,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialEntityUuidBD</name></proto> + <param><type>XrSenseDataSnapshotBD</type> <name>snapshot</name></param> + <param><type>XrSpatialEntityIdBD</type> <name>entityId</name></param> + <param><type>XrUuidEXT</type>* <name>uuid</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_ENTITY_ID_INVALID_BD,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSpatialEntityComponentTypesBD</name></proto> + <param><type>XrSenseDataSnapshotBD</type> <name>snapshot</name></param> + <param><type>XrSpatialEntityIdBD</type> <name>entityId</name></param> + <param optional="true"><type>uint32_t</type> <name>componentTypeCapacityInput</name></param> + <param><type>uint32_t</type>* <name>componentTypeCountOutput</name></param> + <param optional="true" len="componentTypeCapacityInput"><type>XrSpatialEntityComponentTypeBD</type>* <name>componentTypes</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_ENTITY_ID_INVALID_BD,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialEntityComponentDataBD</name></proto> + <param><type>XrSenseDataSnapshotBD</type> <name>snapshot</name></param> + <param>const <type>XrSpatialEntityComponentGetInfoBD</type>* <name>getInfo</name></param> + <param><type>XrSpatialEntityComponentDataBaseHeaderBD</type>* <name>componentData</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSenseDataProviderBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSenseDataProviderCreateInfoBD</type>* <name>createInfo</name></param> + <param><type>XrSenseDataProviderBD</type>* <name>provider</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStartSenseDataProviderAsyncBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param>const <type>XrSenseDataProviderStartInfoBD</type>* <name>startInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStartSenseDataProviderCompleteBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrFutureCompletionEXT</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSenseDataProviderStateBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param><type>XrSenseDataProviderStateBD</type>* <name>state</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrQuerySenseDataAsyncBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param>const <type>XrSenseDataQueryInfoBD</type>* <name>queryInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrQuerySenseDataCompleteBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrSenseDataQueryCompletionBD</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD"> + <proto><type>XrResult</type> <name>xrDestroySenseDataSnapshotBD</name></proto> + <param externsync="true_with_children"><type>XrSenseDataSnapshotBD</type> <name>snapshot</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetQueriedSenseDataBD</name></proto> + <param><type>XrSenseDataSnapshotBD</type> <name>snapshot</name></param> + <param><type>XrQueriedSenseDataGetInfoBD</type>* <name>getInfo</name></param> + <param><type>XrQueriedSenseDataBD</type>* <name>queriedSenseData</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrStopSenseDataProviderBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD"> + <proto><type>XrResult</type> <name>xrDestroySenseDataProviderBD</name></proto> + <param externsync="true_with_children"><type>XrSenseDataProviderBD</type> <name>provider</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialEntityAnchorBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param>const <type>XrSpatialEntityAnchorCreateInfoBD</type>* <name>createInfo</name></param> + <param><type>XrAnchorBD</type>* <name>anchor</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD"> + <proto><type>XrResult</type> <name>xrDestroyAnchorBD</name></proto> + <param externsync="true_with_children"><type>XrAnchorBD</type> <name>anchor</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetAnchorUuidBD</name></proto> + <param><type>XrAnchorBD</type> <name>anchor</name></param> + <param><type>XrUuidEXT</type>* <name>uuid</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateAnchorSpaceBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrAnchorSpaceCreateInfoBD</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>space</name></param> + </command> + + <!-- commands for XR_BD_spatial_anchor --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorAsyncBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param>const <type>XrSpatialAnchorCreateInfoBD</type>* <name>info</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorCompleteBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrSpatialAnchorCreateCompletionBD</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPersistSpatialAnchorAsyncBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param>const <type>XrSpatialAnchorPersistInfoBD</type>* <name>info</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPersistSpatialAnchorCompleteBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrFutureCompletionEXT</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUnpersistSpatialAnchorAsyncBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param>const <type>XrSpatialAnchorUnpersistInfoBD</type>* <name>info</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrUnpersistSpatialAnchorCompleteBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrFutureCompletionEXT</type>* <name>completion</name></param> + </command> + + <!-- commands for XR_BD_spatial_anchor_sharing --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrShareSpatialAnchorAsyncBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param>const <type>XrSpatialAnchorShareInfoBD</type>* <name>info</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrShareSpatialAnchorCompleteBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrFutureCompletionEXT</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrDownloadSharedSpatialAnchorAsyncBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param>const <type>XrSharedSpatialAnchorDownloadInfoBD</type>* <name>info</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrDownloadSharedSpatialAnchorCompleteBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrFutureCompletionEXT</type>* <name>completion</name></param> + </command> + + <!-- commands for XR_BD_spatial_scene --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCaptureSceneAsyncBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param>const <type>XrSceneCaptureInfoBD</type>* <name>info</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCaptureSceneCompleteBD</name></proto> + <param><type>XrSenseDataProviderBD</type> <name>provider</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrFutureCompletionEXT</type>* <name>completion</name></param> + </command> + + <!-- commands for XR_BD_spatial_light_estimation --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateEnvironmentTextureResolutionsBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true"><type>uint32_t</type> <name>resolutionCapacityInput</name></param> + <param><type>uint32_t</type>* <name>resolutionCountOutput</name></param> + <param optional="true" len="resolutionCapacityInput"><type>XrEnvironmentTextureResolutionBD</type>* <name>resolutions</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateEnvironmentTexturePixelFormatsBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true"><type>uint32_t</type> <name>pixelFormatCapacityInput</name></param> + <param><type>uint32_t</type>* <name>pixelFormatCountOutput</name></param> + <param optional="true" len="pixelFormatCapacityInput"><type>XrEnvironmentTexturePixelFormatBD</type>* <name>pixelFormats</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateEnvironmentTextureTransferTypesBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true"><type>uint32_t</type> <name>transferTypeCapacityInput</name></param> + <param><type>uint32_t</type>* <name>transferTypeCountOutput</name></param> + <param optional="true" len="transferTypeCapacityInput"><type>XrEnvironmentTextureTransferTypeBD</type>* <name>transferTypes</name></param> + </command> + + <!-- XR_META_simultaneous_hands_and_controllers commands --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrResumeSimultaneousHandsAndControllersTrackingMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSimultaneousHandsAndControllersTrackingResumeInfoMETA</type>* <name>resumeInfo</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPauseSimultaneousHandsAndControllersTrackingMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSimultaneousHandsAndControllersTrackingPauseInfoMETA</type>* <name>pauseInfo</name></param> + </command> + + <!-- commands for XR_BD_facial_simulation --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateFacialSimulationModesBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true"><type>uint32_t</type> <name>modeCapacityInput</name></param> + <param><type>uint32_t</type>* <name>modeCountOutput</name></param> + <param optional="true" len="modeCapacityInput"><type>XrFacialSimulationModeBD</type>* <name>modes</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateFaceTrackerBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrFaceTrackerCreateInfoBD</type>* <name>createInfo</name></param> + <param><type>XrFaceTrackerBD</type>* <name>tracker</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyFaceTrackerBD</name></proto> + <param externsync="true_with_children"><type>XrFaceTrackerBD</type> <name>tracker</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetFacialSimulationDataBD</name></proto> + <param><type>XrFaceTrackerBD</type> <name>tracker</name></param> + <param>const <type>XrFacialSimulationDataGetInfoBD</type>*<name>info</name></param> + <param><type>XrFacialSimulationDataBD</type>* <name>facialData</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetFacialSimulationModeBD</name></proto> + <param><type>XrFaceTrackerBD</type> <name>tracker</name></param> + <param><type>XrFacialSimulationModeBD</type> <name>mode</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetFacialSimulationModeBD</name></proto> + <param><type>XrFaceTrackerBD</type> <name>tracker</name></param> + <param><type>XrFacialSimulationModeBD</type>*<name>mode</name></param> + </command> + + <!-- XR_ANDROID_geospatial --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateGeospatialTrackerANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrGeospatialTrackerCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrGeospatialTrackerANDROID</type>* <name>geospatialTrackerOutput</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyGeospatialTrackerANDROID</name></proto> + <param externsync="true_with_children"><type>XrGeospatialTrackerANDROID</type> <name>geospatialTracker</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_GEOSPATIAL_TRACKER_NOT_RUNNING_ANDROID,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrLocateGeospatialPoseFromPoseANDROID</name></proto> + <param><type>XrGeospatialTrackerANDROID</type> <name>geospatialTracker</name></param> + <param>const <type>XrGeospatialPoseFromPoseLocateInfoANDROID</type>* <name>locateInfo</name></param> + <param><type>XrGeospatialPoseResultANDROID</type>* <name>geospatialPoseResult</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_GEOSPATIAL_COORDINATES_INVALID_ANDROID,XR_ERROR_GEOSPATIAL_TRACKER_NOT_RUNNING_ANDROID,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrLocateGeospatialPoseANDROID</name></proto> + <param><type>XrGeospatialTrackerANDROID</type> <name>geospatialTracker</name></param> + <param>const <type>XrGeospatialPoseLocateInfoANDROID</type>* <name>locateInfo</name></param> + <param><type>XrSpaceLocation</type>* <name>location</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_GEOSPATIAL_COORDINATES_INVALID_ANDROID,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCheckVpsAvailabilityAsyncANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>double</type> <name>latitude</name></param> + <param><type>double</type> <name>longitude</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCheckVpsAvailabilityCompleteANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrVPSAvailabilityCheckCompletionANDROID</type>* <name>completion</name></param> + </command> + + <!-- XR_ANDROID_geospatial_anchor --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_GEOSPATIAL_COORDINATES_INVALID_ANDROID,XR_ERROR_GEOSPATIAL_TRACKER_NOT_RUNNING_ANDROID,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateGeospatialAnchorANDROID</name></proto> + <param><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + <param>const <type>XrGeospatialAnchorCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrSpatialEntityIdEXT</type>* <name>anchorEntityId</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_GEOSPATIAL_COORDINATES_INVALID_ANDROID,XR_ERROR_GEOSPATIAL_TRACKER_NOT_RUNNING_ANDROID,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSurfaceAnchorAsyncANDROID</name></proto> + <param><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + <param>const <type>XrSurfaceAnchorCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSurfaceAnchorCompleteANDROID</name></proto> + <param><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrSurfaceAnchorCreateCompletionANDROID</type>* <name>completion</name></param> + </command> + + <!-- XR_ANDROID_trackables_image --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_IMAGE_FORMAT_UNSUPPORTED_ANDROID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateTrackableImageDatabaseAsyncANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrTrackableImageDatabaseCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateTrackableImageDatabaseCompleteANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrCreateTrackableImageDatabaseCompletionANDROID</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyTrackableImageDatabaseANDROID</name></proto> + <param externsync="true_with_children"><type>XrTrackableImageDatabaseANDROID</type> <name>database</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrAddTrackableImageDatabaseANDROID</name></proto> + <param><type>XrTrackableTrackerANDROID</type> <name>tracker</name></param> + <param><type>XrTrackableImageDatabaseANDROID</type> <name>database</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRemoveTrackableImageDatabaseANDROID</name></proto> + <param><type>XrTrackableTrackerANDROID</type> <name>tracker</name></param> + <param><type>XrTrackableImageDatabaseANDROID</type> <name>database</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_MISMATCHING_TRACKABLE_TYPE_ANDROID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetTrackableImageANDROID</name></proto> + <param><type>XrTrackableTrackerANDROID</type> <name>tracker</name></param> + <param>const <type>XrTrackableGetInfoANDROID</type>* <name>getInfo</name></param> + <param><type>XrTrackableImageANDROID</type>* <name>trackable</name></param> + </command> + + <!-- XR_ANDROID_spatial_entity_bound_anchor --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSpatialAnchorAttachableComponentsANDROID</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param optional="true"><type>uint32_t</type> <name>attachableComponentCapacityInput</name></param> + <param><type>uint32_t</type>* <name>attachableComponentCountOutput</name></param> + <param optional="true" len="attachableComponentCapacityInput"><type>XrSpatialComponentTypeEXT</type>* <name>attachableComponents</name></param> + </command> + + <!-- XR_ANDROID_spatial_anchor_space --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_ANCHOR_ATTACHABLE_COMPONENT_NOT_FOUND_ANDROID,XR_ERROR_SPATIAL_ENTITY_ID_INVALID_EXT,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorSpaceANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + <param>const <type>XrSpatialAnchorCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrSpatialEntityIdEXT</type>* <name>anchorEntityId</name></param> + <param><type>XrSpace</type>* <name>anchorSpace</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_ANCHOR_ENTITY_ID_INVALID_ANDROID,XR_ERROR_SPATIAL_ENTITY_ID_INVALID_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialAnchorSpaceFromIdANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + <param>const <type>XrSpatialAnchorSpaceFromIdCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>anchorSpace</name></param> + </command> + + <!-- XR_ANDROID_google_cloud_auth --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_KEYLESS_AUTH_NOT_SETUP_ANDROID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetGoogleCloudAuthAsyncANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrGoogleCloudAuthInfoBaseHeaderANDROID</type>* <name>authInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetGoogleCloudAuthCompleteANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrFutureCompletionEXT</type>* <name>completion</name></param> + </command> + + <!-- XR_META_tile_properties_hint commands --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetTilePropertiesHintMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrTilePropertiesHintMETA</type>* <name>properties</name></param> + </command> + + <!-- XR_META_environment_raycast --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateEnvironmentRaycasterAsyncMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param optional="true">const <type>XrEnvironmentRaycasterCreateInfoMETA</type>* <name>info</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INITIALIZATION_FAILED,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SESSION_NOT_RUNNING,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateEnvironmentRaycasterCompleteMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrEnvironmentRaycasterCreateCompletionMETA</type>* <name>completion</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyEnvironmentRaycasterMETA</name></proto> + <param externsync="true_with_children"><type>XrEnvironmentRaycasterMETA</type> <name>environmentRaycaster</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrPerformEnvironmentRaycastMETA</name></proto> + <param><type>XrEnvironmentRaycasterMETA</type> <name>environmentRaycaster</name></param> + <param>const <type>XrEnvironmentRaycastHitGetInfoMETA</type>* <name>info</name></param> + <param><type>XrEnvironmentRaycastHitMETA</type>* <name>hitPoint</name></param> + </command> + + <!-- XR_ANDROID_spatial_discovery_raycast commands --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_COMPONENT_NOT_ENABLED_EXT,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialRaycastSnapshotANDROID</name></proto> + <param><type>XrSpatialContextEXT</type> <name>spatialContext</name></param> + <param>const <type>XrSpatialRaycastSnapshotCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrSpatialSnapshotEXT</type>* <name>snapshot</name></param> + </command> + + <!-- XR_QCOM_hand_tracking_gesture --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID"> + <proto><type>XrResult</type> <name>xrGetHandGestureQCOM</name></proto> + <param><type>XrHandTrackerEXT</type> <name>handTracker</name></param> + <param><type>XrTime</type> <name>time</name></param> + <param><type>XrHandGestureQCOM</type>* <name>handGesture</name></param> + </command> + + <!-- XR_META_hand_tracking_frequency --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetHandTrackingFrequencyHintMETA</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrHandTrackingFrequencyHintMETA</type> <name>frequencyHint</name></param> + </command> + + <!-- XR_EXT_haptic_parametric --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_ACTIONSET_NOT_ATTACHED,XR_ERROR_ACTION_TYPE_MISMATCH,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PATH_INVALID,XR_ERROR_PATH_UNSUPPORTED,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrHapticParametricGetPropertiesEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrHapticActionInfo</type>* <name>hapticActionInfo</name></param> + <param><type>XrHapticParametricPropertiesEXT</type>* <name>parametricProperties</name></param> + </command> + + <!-- XR_SONY_swapchain_color_space --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateColorSpacesSONY</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrColorSpacesEnumerateInfoSONY</type>* <name>enumerateInfo</name></param> + <param optional="true"><type>uint32_t</type> <name>colorSpaceCapacityInput</name></param> + <param><type>uint32_t</type>* <name>colorSpaceCountOutput</name></param> + <param optional="true" len="colorSpaceCapacityInput"><type>XrColorSpaceSONY</type>* <name>colorSpaces</name></param> + </command> + + <!-- XR_BD_camera_image commands --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateAvailableCamerasBD</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrAvailableCamerasEnumerateInfoBD</type>* <name>enumerateInfo</name></param> + <param optional="true"><type>uint32_t</type> <name>cameraCapacityInput</name></param> + <param><type>uint32_t</type>* <name>cameraCountOutput</name></param> + <param len="cameraCapacityInput" optional="true"><type>XrAvailableCameraBD</type>* <name>cameras</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_CAMERA_ID_INVALID_BD,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateCameraPropertyTypesBD</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrCameraPropertyTypesEnumerateInfoBD</type>* <name>enumerateInfo</name></param> + <param><type>XrCameraPropertyTypesBD</type>* <name>propertyTypes</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_CAMERA_ID_INVALID_BD,XR_ERROR_CAMERA_PROPERTY_TYPE_INVALID_BD,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetCameraPropertiesBD</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrCameraPropertiesGetInfoBD</type>* <name>getInfo</name></param> + <param><type>XrCameraPropertiesBD</type>* <name>properties</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_CAMERA_ID_INVALID_BD,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateCameraCapabilityTypesBD</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrCameraCapabilityTypesEnumerateInfoBD</type>* <name>enumerateInfo</name></param> + <param><type>XrCameraCapabilityTypesBD</type>* <name>capabilityTypes</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_CAMERA_CAPABILITY_TYPE_INVALID_BD,XR_ERROR_CAMERA_ID_INVALID_BD,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetCameraSupportedCapabilitiesBD</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrCameraSupportedCapabilitiesGetInfoBD</type>* <name>getInfo</name></param> + <param><type>XrCameraSupportedCapabilitiesBD</type>* <name>capabilities</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_CAMERA_ID_INVALID_BD,XR_ERROR_CAMERA_OCCUPIED_BD,XR_ERROR_CAMERA_UNAVAILABLE_BD,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateCameraDeviceAsyncBD</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param>const <type>XrCameraDeviceCreateInfoBD</type>* <name>createInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateCameraDeviceCompleteBD</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrCreateCameraDeviceCompletionBD</type>* <name>completion</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyCameraDeviceBD</name></proto> + <param externsync="true_with_children"><type>XrCameraDeviceBD</type> <name>device</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CAMERA_ID_INVALID_BD,XR_ERROR_CAMERA_OCCUPIED_BD,XR_ERROR_CAMERA_UNAVAILABLE_BD,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateCameraCaptureSessionAsyncBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrCameraCaptureSessionCreateInfoBD</type>* <name>createInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CAMERA_OCCUPIED_BD,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateCameraCaptureSessionCompleteBD</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrCreateCameraCaptureSessionCompletionBD</type>* <name>completion</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyCameraCaptureSessionBD</name></proto> + <param externsync="true_with_children"><type>XrCameraCaptureSessionBD</type> <name>captureSession</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_CAMERA_CAPTURE_SESSION_CAPTURING_BD,XR_ERROR_CAMERA_OCCUPIED_BD,XR_ERROR_CAMERA_UNAVAILABLE_BD,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrBeginCameraCaptureBD</name></proto> + <param><type>XrCameraCaptureSessionBD</type> <name>captureSession</name></param> + <param>const <type>XrCameraCaptureBeginInfoBD</type>* <name>beginInfo</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_CAMERA_CAPTURE_SESSION_NOT_CAPTURING_BD,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEndCameraCaptureBD</name></proto> + <param><type>XrCameraCaptureSessionBD</type> <name>captureSession</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_CAMERA_CAPTURE_SESSION_NOT_CAPTURING_BD,XR_ERROR_CAMERA_OCCUPIED_BD,XR_ERROR_CAMERA_UNAVAILABLE_BD,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_IMAGE_BUFFER_EXHAUSTED_BD,XR_ERROR_INSTANCE_LOST,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrAcquireCameraImageBD</name></proto> + <param><type>XrCameraCaptureSessionBD</type> <name>captureSession</name></param> + <param>const <type>XrCameraImageAcquireInfoBD</type>* <name>acquireInfo</name></param> + <param><type>XrCameraImageBD</type>* <name>image</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_CAMERA_IMAGE_ID_INVALID_BD,XR_ERROR_CAMERA_UNAVAILABLE_BD,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetCameraImageDataBD</name></proto> + <param><type>XrCameraCaptureSessionBD</type> <name>captureSession</name></param> + <param><type>XrCameraImageIdBD</type> <name>imageId</name></param> + <param><type>XrCameraImageDataBaseHeaderBD</type>* <name>imageData</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_CAMERA_IMAGE_ID_INVALID_BD,XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrReleaseCameraImageBD</name></proto> + <param><type>XrCameraCaptureSessionBD</type> <name>captureSession</name></param> + <param><type>XrCameraImageIdBD</type> <name>imageId</name></param> + </command> + + <!-- XR_SONY_hdr_metadata --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrSetHdrMetadataSONY</name></proto> + <param><type>XrSwapchain</type> <name>swapchain</name></param> + <param>const <type>XrHdrMetadataSONY</type>* <name>hdrMetadata</name></param> + </command> + + <!-- XR_ANDROID_trackables --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSupportedTrackableTypesANDROID</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param optional="true"><type>uint32_t</type> <name>trackableTypeCapacityInput</name></param> + <param><type>uint32_t</type>* <name>trackableTypeCountOutput</name></param> + <param optional="true" len="trackableTypeCapacityInput"><type>XrTrackableTypeANDROID</type>* <name>trackableTypes</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSupportedAnchorTrackableTypesANDROID</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param optional="true"><type>uint32_t</type> <name>trackableTypeCapacityInput</name></param> + <param><type>uint32_t</type>* <name>trackableTypeCountOutput</name></param> + <param optional="true" len="trackableTypeCapacityInput"><type>XrTrackableTypeANDROID</type>* <name>trackableTypes</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateTrackableTrackerANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrTrackableTrackerCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrTrackableTrackerANDROID</type>* <name>trackableTracker</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroyTrackableTrackerANDROID</name></proto> + <param externsync="true_with_children"><type>XrTrackableTrackerANDROID</type> <name>trackableTracker</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetAllTrackablesANDROID</name></proto> + <param><type>XrTrackableTrackerANDROID</type> <name>trackableTracker</name></param> + <param optional="true"><type>uint32_t</type> <name>trackableCapacityInput</name></param> + <param><type>uint32_t</type>* <name>trackableCountOutput</name></param> + <param optional="true" len="trackableCapacityInput"><type>XrTrackableANDROID</type>* <name>trackables</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_MISMATCHING_TRACKABLE_TYPE_ANDROID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetTrackablePlaneANDROID</name></proto> + <param><type>XrTrackableTrackerANDROID</type> <name>trackableTracker</name></param> + <param>const <type>XrTrackableGetInfoANDROID</type>* <name>getInfo</name></param> + <param><type>XrTrackablePlaneANDROID</type>* <name>planeOutput</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_POSE_INVALID,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_TIME_INVALID,XR_ERROR_TRACKABLE_TYPE_NOT_SUPPORTED_ANDROID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateAnchorSpaceANDROID</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrAnchorSpaceCreateInfoANDROID</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>anchorOutput</name></param> + </command> + + <!-- XR_EXT_spatial_container --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_CONTAINERS_NOT_ENABLED_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialContainerEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialContainerCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrSpatialContainerEXT</type>* <name>spatialContainer</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpatialContainerEXT</name></proto> + <param externsync="true_with_children"><type>XrSpatialContainerEXT</type> <name>spatialContainer</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_CONTAINER_CLOSED_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialContainerSpaceEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialContainerSpaceCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrSpace</type>* <name>space</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_CONTAINER_CLOSED_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRequestSpatialContainerVisibleEXT</name></proto> + <param><type>XrSpatialContainerEXT</type> <name>spatialContainer</name></param> + <param>const <type>XrSpatialContainerVisibleRequestInfoEXT</type>* <name>info</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_CONTAINER_CLOSED_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrRequestSpatialContainerBoundsModeEXT</name></proto> + <param><type>XrSpatialContainerEXT</type> <name>spatialContainer</name></param> + <param>const <type>XrSpatialContainerBoundsModeRequestInfoEXT</type>* <name>info</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_CONTAINER_CLOSED_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialContainerBoundsEXT</name></proto> + <param><type>XrSpatialContainerEXT</type> <name>spatialContainer</name></param> + <param optional="true">const <type>XrSpatialContainerBoundsGetInfoEXT</type>* <name>getInfo</name></param> + <param><type>XrSpatialContainerBoundsEXT</type>* <name>bounds</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_CONTAINER_CLOSED_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrGetSpatialContainerStateEXT</name></proto> + <param><type>XrSpatialContainerEXT</type> <name>spatialContainer</name></param> + <param optional="true">const <type>XrSpatialContainerStateGetInfoEXT</type>* <name>getInfo</name></param> + <param><type>XrSpatialContainerStateEXT</type>* <name>state</name></param> + </command> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSupportedSpatialContainerGraphicsPresentationsEXT</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param optional="true"><type>uint32_t</type> <name>graphicsPresentationCapacityInput</name></param> + <param><type>uint32_t</type>* <name>graphicsPresentationCountOutput</name></param> + <param optional="true" len="graphicsPresentationCapacityInput"><type>XrSpatialContainerGraphicsPresentationEXT</type>* <name>graphicsPresentations</name></param> + </command> + + <!-- XR_EXT_spatial_container_self_rendering --> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_CONTAINER_NOT_RENDERING_EXT,XR_ERROR_TIME_INVALID,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED"> + <proto><type>XrResult</type> <name>xrLocateSpatialContainerViewsEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialContainerViewsLocateInfoEXT</type>* <name>locateInfo</name></param> + <param><type>uint32_t</type> <name>viewStateCount</name></param> + <param len="viewStateCount"><type>XrSpatialContainerViewStateEXT</type>* <name>viewStates</name></param> + <param><type>uint32_t</type> <name>viewCount</name></param> + <param len="viewCount"><type>XrView</type>* <name>views</name></param> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_CONTAINER_GRAPHICS_PRESENTATION_MISSING_EXT,XR_ERROR_SPATIAL_CONTAINER_IS_RENDERING_EXT,XR_ERROR_VALIDATION_FAILURE,XR_ERROR_VIEW_CONFIGURATION_TYPE_UNSUPPORTED"> + <proto><type>XrResult</type> <name>xrBeginSpatialContainerRenderingEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialContainerBeginInfoEXT</type>* <name>beginInfo</name></param> + <implicitexternsyncparams> + <param>the pname:session parameter by any other flink:xrBeginSpatialContainerRenderingEXT, flink:xrEndSpatialContainerRenderingEXT, or flink:xrEndFrame call</param> + </implicitexternsyncparams> + </command> + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_CALL_ORDER_INVALID,XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_CONTAINER_NOT_RENDERING_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEndSpatialContainerRenderingEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialContainerEndInfoEXT</type>* <name>endInfo</name></param> + <implicitexternsyncparams> + <param>the pname:session parameter by any other flink:xrBeginSpatialContainerRenderingEXT, flink:xrEndSpatialContainerRenderingEXT, or flink:xrEndFrame call</param> + </implicitexternsyncparams> + </command> + + <!-- XR_EXT_spatial_image_tracking --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SIZE_INSUFFICIENT,XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT,XR_ERROR_SYSTEM_INVALID,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrEnumerateSpatialReferenceImageFormatsEXT</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrSystemId</type> <name>systemId</name></param> + <param><type>XrSpatialCapabilityEXT</type> <name>capability</name></param> + <param optional="true"><type>uint32_t</type> <name>formatCapacityInput</name></param> + <param><type>uint32_t</type>* <name>formatCountOutput</name></param> + <param optional="true" len="formatCapacityInput"><type>XrSpatialReferenceImageFormatEXT</type>* <name>formats</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_PERMISSION_INSUFFICIENT,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_SPATIAL_IMAGE_FORMAT_UNSUPPORTED_EXT,XR_ERROR_SPATIAL_IMAGE_INVALID_EXT,XR_ERROR_SPATIAL_IMAGE_SIZE_MISSING_EXT,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialImageTrackingDatabaseAsyncEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param>const <type>XrSpatialImageTrackingDatabaseCreateInfoEXT</type>* <name>createInfo</name></param> + <param><type>XrFutureEXT</type>* <name>future</name></param> + </command> + + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_RUNTIME_FAILURE"> + <proto><type>XrResult</type> <name>xrDestroySpatialImageTrackingDatabaseEXT</name></proto> + <param externsync="true_with_children"><type>XrSpatialImageTrackingDatabaseEXT</type> <name>database</name></param> + </command> + + <command successcodes="XR_SUCCESS,XR_SESSION_LOSS_PENDING" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_FUTURE_INVALID_EXT,XR_ERROR_FUTURE_PENDING_EXT,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_LIMIT_REACHED,XR_ERROR_OUT_OF_MEMORY,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_SESSION_LOST,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrCreateSpatialImageTrackingDatabaseCompleteEXT</name></proto> + <param><type>XrSession</type> <name>session</name></param> + <param><type>XrFutureEXT</type> <name>future</name></param> + <param><type>XrCreateSpatialImageTrackingDatabaseCompletionEXT</type>* <name>completion</name></param> + </command> + + <!-- XR_KHR_extended_result_name_lengths --> + <command successcodes="XR_SUCCESS" errorcodes="XR_ERROR_FUNCTION_UNSUPPORTED,XR_ERROR_HANDLE_INVALID,XR_ERROR_INSTANCE_LOST,XR_ERROR_RUNTIME_FAILURE,XR_ERROR_VALIDATION_FAILURE"> + <proto><type>XrResult</type> <name>xrResultToString2KHR</name></proto> + <param><type>XrInstance</type> <name>instance</name></param> + <param><type>XrResult</type> <name>value</name></param> + <param><type>char</type> <name>buffer</name>[<enum>XR_MAX_RESULT_STRING_SIZE_EXTENDED_KHR</enum>]</param> + </command> + + </commands> + + <interaction_profiles> + <interaction_profile name="/interaction_profiles/khr/simple_controller" title="Khronos Simple Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/select/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <interaction_profile name="/interaction_profiles/google/daydream_controller" title="Google Daydream Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/select/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/trackpad/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </interaction_profile> + + <interaction_profile name="/interaction_profiles/htc/vive_controller" title="HTC Vive Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/trackpad/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <interaction_profile name="/interaction_profiles/htc/vive_pro" title="HTC Vive Pro"> + <user_path path="/user/head"/> + <component subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/volume_up/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/volume_down/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/mute_mic/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </interaction_profile> + + <interaction_profile name="/interaction_profiles/microsoft/motion_controller" title="Microsoft Mixed Reality Motion Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/trackpad/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <interaction_profile name="/interaction_profiles/microsoft/xbox_controller" title="Microsoft Xbox Controller"> + <user_path path="/user/gamepad"/> + <component subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/view/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/dpad_down/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/dpad_right/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/dpad_up/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/dpad_left/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/shoulder_left/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/shoulder_right/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick_left/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick_right/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger_left/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger_right/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick_left" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick_left/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick_left/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick_right" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick_right/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick_right/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/output/haptic_left" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + <component subpath="/output/haptic_right" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + <component subpath="/output/haptic_left_trigger" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + <component subpath="/output/haptic_right_trigger" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + + <interaction_profile name="/interaction_profiles/oculus/go_controller" title="Oculus Go Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/back/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/trackpad/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </interaction_profile> + + <interaction_profile name="/interaction_profiles/oculus/touch_controller" title="Oculus Touch Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbrest/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <interaction_profile name="/interaction_profiles/valve/index_controller" title="Valve Index Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/system/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/squeeze/force" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/trackpad/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/force" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_EXT_eye_gaze_interaction --> + + <interaction_profile name="/interaction_profiles/ext/eye_gaze_interaction" title="Multivendor eye gaze interaction"> + <user_path path="/user/eyes_ext"/> + <component subpath="/input/gaze_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </interaction_profile> + + <!-- XR_MSFT_hand_interaction --> + + <interaction_profile name="/interaction_profiles/microsoft/hand_interaction" title="Microsoft hand interaction"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/select/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </interaction_profile> + + <!-- XR_HUAWEI_controller_interaction --> + + <interaction_profile name="/interaction_profiles/huawei/controller" title="Huawei Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/home/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/back/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/volume_up/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/volume_down/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/trackpad/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_HTC_hand_interaction --> + + <interaction_profile name="/interaction_profiles/htc/hand_interaction" title="HTC hand interaction"> + <user_path path="/user/hand_htc/left"/> + <user_path path="/user/hand_htc/right"/> + <component subpath="/input/select/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </interaction_profile> + + <!-- XR_HTC_vive_wrist_tracker_interaction --> + + <interaction_profile name="/interaction_profiles/htc/vive_wrist_tracker" title="HTC VIVE Wrist Tracker"> + <user_path path="/user/wrist_htc/left"/> + <user_path path="/user/wrist_htc/right"/> + <component user_path="/user/wrist_htc/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/wrist_htc/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/wrist_htc/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/wrist_htc/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/entity_htc/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </interaction_profile> + + <!-- XR_HTC_vive_cosmos_controller_interaction --> + + <interaction_profile name="/interaction_profiles/htc/vive_cosmos_controller" title="HTC VIVE Cosmos Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + + <component subpath="/input/shoulder/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_HTC_vive_focus3_controller_interaction --> + + <interaction_profile name="/interaction_profiles/htc/vive_focus3_controller" title="HTC VIVE Focus 3 Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + + <component subpath="/input/squeeze/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbrest/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_HTCX_vive_tracker_interaction --> + + <interaction_profile name="/interaction_profiles/htc/vive_tracker_htcx" title="HTC VIVE Tracker"> + <user_path path="/user/vive_tracker_htcx/role/handheld_object"/> + <user_path path="/user/vive_tracker_htcx/role/left_foot"/> + <user_path path="/user/vive_tracker_htcx/role/right_foot"/> + <user_path path="/user/vive_tracker_htcx/role/left_shoulder"/> + <user_path path="/user/vive_tracker_htcx/role/right_shoulder"/> + <user_path path="/user/vive_tracker_htcx/role/left_elbow"/> + <user_path path="/user/vive_tracker_htcx/role/right_elbow"/> + <user_path path="/user/vive_tracker_htcx/role/left_knee"/> + <user_path path="/user/vive_tracker_htcx/role/right_knee"/> + <user_path path="/user/vive_tracker_htcx/role/left_wrist"/> + <user_path path="/user/vive_tracker_htcx/role/right_wrist"/> + <user_path path="/user/vive_tracker_htcx/role/left_ankle"/> + <user_path path="/user/vive_tracker_htcx/role/right_ankle"/> + <user_path path="/user/vive_tracker_htcx/role/waist"/> + <user_path path="/user/vive_tracker_htcx/role/chest"/> + <user_path path="/user/vive_tracker_htcx/role/camera"/> + <user_path path="/user/vive_tracker_htcx/role/keyboard"/> + + <component subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/trackpad/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_EXT_samsung_odyssey_controller --> + + <interaction_profile name="/interaction_profiles/samsung/odyssey_controller" title="Samsung Odyssey Mixed Reality Motion Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/trackpad/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_EXT_hp_mixed_reality_controller --> + + <interaction_profile name="/interaction_profiles/hp/mixed_reality_controller" title="HP Mixed Reality Motion Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_ML_ml2_controller_interaction --> + + <interaction_profile name="/interaction_profiles/ml/ml2_controller" title="Magic Leap 2 Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/home/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/trackpad/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/force" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trackpad/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/shoulder/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_FB_touch_pro_controller --> + <interaction_profile name="/interaction_profiles/facebook/touch_controller_pro" title="Meta Quest Touch Pro Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbrest/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + <component subpath="/input/thumbrest/force" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/stylus_fb/force" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/curl_fb" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/slide_fb" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumb_fb/proximity_fb" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/proximity_fb" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/output/haptic_trigger_fb" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + <component subpath="/output/haptic_thumb_fb" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_META_touch_controller_plus --> + <interaction_profile name="/interaction_profiles/meta/touch_controller_plus" title="Meta Quest Touch Plus Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbrest/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + <component subpath="/input/thumb_meta/proximity_meta" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/proximity_meta" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/curl_meta" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/slide_meta" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/force" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + </interaction_profile> + + <!-- 1.1 Meta Interaction Profiles --> + <!-- Promoted and renamed --> + <interaction_profile name="/interaction_profiles/meta/touch_pro_controller" title="Meta Quest Touch Pro Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbrest/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + <component subpath="/input/thumbrest/force" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/stylus/force" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumb_resting_surfaces/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger_curl/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger_slide/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/output/haptic_trigger" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + <component subpath="/output/haptic_thumb" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- Promoted and renamed --> + <interaction_profile name="/interaction_profiles/meta/touch_plus_controller" title="Meta Quest Touch Plus Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbrest/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + <component subpath="/input/thumb_resting_surfaces/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger_curl/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger_slide/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/force" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + </interaction_profile> + + <!-- New legacy profile --> + <interaction_profile name="/interaction_profiles/meta/touch_controller_rift_cv1" title="Rift CV1 Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumb_resting_surfaces/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbrest/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- New legacy profile --> + <interaction_profile name="/interaction_profiles/meta/touch_controller_quest_1_rift_s" title="Quest / Rift S Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumb_resting_surfaces/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- New legacy profile --> + <interaction_profile name="/interaction_profiles/meta/touch_controller_quest_2" title="Quest 2 Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumb_resting_surfaces/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbrest/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + <!-- (END) 1.1 Meta Interaction Profiles --> + + + <!-- XR_BD_controller_interaction --> + + <interaction_profile name="/interaction_profiles/bytedance/pico_neo3_controller" title="ByteDance PICO Neo3 Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <interaction_profile name="/interaction_profiles/bytedance/pico4_controller" title="ByteDance PICO 4 Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <interaction_profile name="/interaction_profiles/bytedance/pico_g3_controller" title="ByteDance PICO G3 Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </interaction_profile> + + <interaction_profile name="/interaction_profiles/bytedance/pico_ultra_controller_bd" title="PICO Ultra Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + + <!-- XR_EXT_hand_interaction --> + <interaction_profile name="/interaction_profiles/ext/hand_interaction_ext" title="EXT hand interaction profile"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/pinch_ext/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/pinch_ext/ready_ext" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grasp_ext/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/grasp_ext/ready_ext" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/aim_activate_ext/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/aim_activate_ext/ready_ext" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </interaction_profile> + + <!-- XR_ANDROID_mouse_interaction --> + <interaction_profile name="/interaction_profiles/android/mouse_interaction_android" title="ANDROID mouse interaction profile"> + <user_path path="/user/mouse"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/select/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/secondary_android/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/tertiary_android/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/scroll_android/value" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + </interaction_profile> + + <!-- XR_OPPO_controller_interaction --> + <interaction_profile name="/interaction_profiles/oppo/mr_controller_oppo" title="OPPO MR Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/heartrate_oppo/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/home/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_YVR_controller_interaction --> + <interaction_profile name="/interaction_profiles/yvr/touch_controller_yvr" title="YVR Touch Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/x/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/x/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/y/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/squeeze/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_VARJO_xr4_controller_interaction --> + <interaction_profile name="/interaction_profiles/varjo/xr-4_controller" title="Varjo XR-4 Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component user_path="/user/hand/left" subpath="/input/menu/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component user_path="/user/hand/right" subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/a/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/a/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/b/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/b/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/squeeze/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/touch" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_LOGITECH_mx_ink_stylus_interaction --> + <interaction_profile name="/interaction_profiles/logitech/mx_ink_stylus_logitech" title="Logitech MX Ink Stylus"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/tip_logitech/force" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/cluster_middle_logitech/force" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/cluster_front_logitech/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/cluster_front_logitech/double_tap_logitech" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/cluster_back_logitech/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/cluster_back_logitech/double_tap_logitech" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/system/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT" system="true"/> + <component subpath="/input/dock_logitech/docked_logitech" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/tip_logitech/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + <!-- XR_KHR_generic_controller --> + <interaction_profile name="/interaction_profiles/khr/generic_controller" title="Khronos Generic Controller"> + <user_path path="/user/hand/left"/> + <user_path path="/user/hand/right"/> + <component subpath="/input/primary/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/secondary/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + + <component subpath="/input/thumbstick" type="XR_ACTION_TYPE_VECTOR2F_INPUT"/> + <component subpath="/input/thumbstick/x" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/y" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/thumbstick/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + + <component subpath="/input/squeeze/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + <component subpath="/input/trigger/value" type="XR_ACTION_TYPE_FLOAT_INPUT"/> + + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/aim/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/output/haptic" type="XR_ACTION_TYPE_VIBRATION_OUTPUT"/> + </interaction_profile> + + </interaction_profiles> + + <!-- SECTION: OpenXR 1.0 API interface definitions --> + <feature api="openxr" name="XR_VERSION_1_0" number="1.0"> + <require comment="Header boilerplate"> + <type name="openxr_platform_defines"/> + </require> + <require comment="API version"> + <type name="XR_CURRENT_API_VERSION"/> + <type name="XR_API_VERSION_1_0"/> + <type name="XR_VERSION_MAJOR"/> + <type name="XR_VERSION_MINOR"/> + <type name="XR_VERSION_PATCH"/> + <type name="XrVersion"/> + </require> + <require comment="API constants"> + <enum name="XR_TRUE"/> + <enum name="XR_FALSE"/> + <enum name="XR_MAX_EXTENSION_NAME_SIZE"/> + <enum name="XR_MAX_API_LAYER_NAME_SIZE"/> + <enum name="XR_MAX_API_LAYER_DESCRIPTION_SIZE"/> + <enum name="XR_MAX_SYSTEM_NAME_SIZE"/> + <enum name="XR_MAX_APPLICATION_NAME_SIZE"/> + <enum name="XR_MAX_ENGINE_NAME_SIZE"/> + <enum name="XR_MAX_RUNTIME_NAME_SIZE"/> + <enum name="XR_MAX_PATH_LENGTH"/> + <enum name="XR_MAX_STRUCTURE_NAME_SIZE"/> + <enum name="XR_MAX_RESULT_STRING_SIZE"/> + <type name="XR_MIN_COMPOSITION_LAYERS_SUPPORTED"/> + <type name="XR_NULL_HANDLE"/> + <type name="XR_NULL_SYSTEM_ID"/> + <type name="XR_NULL_PATH"/> + <type name="XR_SUCCEEDED"/> + <type name="XR_FAILED"/> + <type name="XR_UNQUALIFIED_SUCCESS"/> + <type name="XR_NO_DURATION"/> + <type name="XR_INFINITE_DURATION"/> + <type name="XR_MIN_HAPTIC_DURATION"/> + <type name="XR_FREQUENCY_UNSPECIFIED"/> + <type name="XR_MAX_EVENT_DATA_SIZE"/> + <type name="XR_EXTENSION_ENUM_BASE"/> + <type name="XR_EXTENSION_ENUM_STRIDE"/> + </require> + <require comment="API macros"> + <type name="XR_MAY_ALIAS"/> + <type name="XR_DEFINE_HANDLE"/> + <type name="XR_DEFINE_OPAQUE_64"/> + + <type name="XR_DEFINE_ATOM"/> + <type name="XR_MAKE_VERSION"/> + </require> + <require comment="Result"> + <type name="XrResult"/> + </require> + <require comment="Instance"> + <command name="xrGetInstanceProcAddr"/> + <command name="xrEnumerateApiLayerProperties"/> + <command name="xrEnumerateInstanceExtensionProperties"/> + <command name="xrCreateInstance"/> + <command name="xrDestroyInstance"/> + <command name="xrGetInstanceProperties"/> + <command name="xrPollEvent"/> + <command name="xrResultToString"/> + <command name="xrStructureTypeToString"/> + + <type name="PFN_xrVoidFunction"/> + <type name="XrApiLayerProperties"/> + <type name="XrExtensionProperties"/> + <type name="XrInstance"/> + <type name="XrInstanceCreateInfo"/> + <type name="XrInstanceCreateFlags"/> + <type name="XrInstanceCreateFlagBits"/> + <type name="XrApplicationInfo"/> + <type name="XrInstanceProperties"/> + <type name="XrEventDataBuffer"/> + <type name="XrStructureType"/> + </require> + <require comment="Device"> + <command name="xrGetSystem"/> + <command name="xrGetSystemProperties"/> + <command name="xrEnumerateEnvironmentBlendModes"/> + <command name="xrCreateSession"/> + <command name="xrDestroySession"/> + + <type name="XrSystemId"/> + <type name="XrFormFactor"/> + <type name="XrSystemGetInfo"/> + <type name="XrSystemProperties"/> + <type name="XrSystemGraphicsProperties"/> + <type name="XrSystemTrackingProperties"/> + <type name="XrEnvironmentBlendMode"/> + <type name="XrSession"/> + <type name="XrSessionCreateInfo"/> + <type name="XrSessionCreateFlags"/> + <type name="XrSessionCreateFlagBits"/> + </require> + <require comment="Space"> + <command name="xrEnumerateReferenceSpaces"/> + <command name="xrCreateReferenceSpace"/> + <command name="xrGetReferenceSpaceBoundsRect"/> + <command name="xrCreateActionSpace"/> + <command name="xrLocateSpace"/> + <command name="xrDestroySpace"/> + + <type name="XrSpace"/> + <type name="XrReferenceSpaceCreateInfo"/> + <type name="XrReferenceSpaceType"/> + <type name="XrActionSpaceCreateInfo"/> + <type name="XrSpaceLocation"/> + <type name="XrSpaceLocationFlags"/> + <type name="XrSpaceLocationFlagBits"/> + <type name="XrSpaceVelocity"/> + <type name="XrSpaceVelocityFlags"/> + <type name="XrSpaceVelocityFlagBits"/> + <type name="XrPosef"/> + <type name="XrVector3f"/> + <type name="XrQuaternionf"/> + </require> + <require comment="ViewConfigurations"> + <command name="xrEnumerateViewConfigurations"/> + <command name="xrGetViewConfigurationProperties"/> + <command name="xrEnumerateViewConfigurationViews"/> + + <type name="XrViewConfigurationType"/> + <type name="XrViewConfigurationProperties"/> + <type name="XrViewConfigurationView"/> + </require> + <require comment="Image"> + <command name="xrEnumerateSwapchainFormats"/> + <command name="xrCreateSwapchain"/> + <command name="xrDestroySwapchain"/> + <command name="xrEnumerateSwapchainImages"/> + <command name="xrAcquireSwapchainImage"/> + <command name="xrWaitSwapchainImage"/> + <command name="xrReleaseSwapchainImage"/> + + <type name="XrSwapchain"/> + <type name="XrSwapchainCreateInfo"/> + <type name="XrSwapchainCreateFlags"/> + <type name="XrSwapchainCreateFlagBits"/> + <type name="XrSwapchainUsageFlags"/> + <type name="XrSwapchainUsageFlagBits"/> + <type name="XrSwapchainImageBaseHeader"/> + <type name="XrSwapchainImageAcquireInfo"/> + <type name="XrSwapchainImageWaitInfo"/> + <type name="XrDuration"/> + <type name="XrSwapchainImageReleaseInfo"/> + </require> + <require comment="Session"> + <command name="xrBeginSession"/> + <command name="xrEndSession"/> + <command name="xrRequestExitSession"/> + <type name="XrSessionBeginInfo"/> + </require> + <require comment="Display Timing"> + <command name="xrWaitFrame"/> + <command name="xrBeginFrame"/> + <command name="xrEndFrame"/> + <command name="xrLocateViews"/> + + <type name="XrFrameState"/> + <type name="XrFrameWaitInfo"/> + <type name="XrFrameBeginInfo"/> + <type name="XrFrameEndInfo"/> + <type name="XrCompositionLayerBaseHeader"/> + <type name="XrCompositionLayerFlags"/> + <type name="XrCompositionLayerFlagBits"/> + <type name="XrEyeVisibility"/> + <type name="XrViewState"/> + <type name="XrViewStateFlags"/> + <type name="XrViewStateFlagBits"/> + <type name="XrViewLocateInfo"/> + <type name="XrTime"/> + <type name="XrView"/> + <type name="XrFovf"/> + </require> + <require comment="Semantic Paths"> + <command name="xrStringToPath"/> + <command name="xrPathToString"/> + + <type name="XrPath"/> + + <interaction_profile name="/interaction_profiles/khr/simple_controller"/> + <interaction_profile name="/interaction_profiles/google/daydream_controller"/> + <interaction_profile name="/interaction_profiles/htc/vive_controller"/> + <interaction_profile name="/interaction_profiles/htc/vive_pro"/> + <interaction_profile name="/interaction_profiles/microsoft/motion_controller"/> + <interaction_profile name="/interaction_profiles/microsoft/xbox_controller"/> + <interaction_profile name="/interaction_profiles/oculus/go_controller"/> + <interaction_profile name="/interaction_profiles/oculus/touch_controller"/> + <interaction_profile name="/interaction_profiles/valve/index_controller"/> + </require> + <require comment="Input"> + <command name="xrCreateActionSet"/> + <command name="xrDestroyActionSet"/> + <command name="xrCreateAction"/> + <command name="xrDestroyAction"/> + <command name="xrSuggestInteractionProfileBindings"/> + <command name="xrAttachSessionActionSets"/> + <command name="xrGetCurrentInteractionProfile"/> + <command name="xrGetActionStateBoolean"/> + <command name="xrGetActionStateFloat"/> + <command name="xrGetActionStateVector2f"/> + <command name="xrGetActionStatePose"/> + <command name="xrSyncActions"/> + <command name="xrEnumerateBoundSourcesForAction"/> + <command name="xrGetInputSourceLocalizedName"/> + + <type name="XrActionSet"/> + <type name="XrActionSetCreateInfo"/> + <type name="XrAction"/> + <type name="XrActionCreateInfo"/> + <type name="XrActionType"/> + <type name="XrInteractionProfileSuggestedBinding"/> + <type name="XrActionSuggestedBinding"/> + <type name="XrSessionActionSetsAttachInfo"/> + <type name="XrInteractionProfileState"/> + <type name="XrActionStateGetInfo"/> + <type name="XrActionStateBoolean"/> + <type name="XrActionStateFloat"/> + <type name="XrActionStateVector2f"/> + <type name="XrVector2f"/> + <type name="XrActionStatePose"/> + <type name="XrActionsSyncInfo"/> + <type name="XrActiveActionSet"/> + <type name="XrBoundSourcesForActionEnumerateInfo"/> + <type name="XrInputSourceLocalizedNameGetInfo"/> + <type name="XrInputSourceLocalizedNameFlags"/> + <type name="XrInputSourceLocalizedNameFlagBits"/> + </require> + <require comment="Haptics"> + <command name="xrApplyHapticFeedback"/> + <command name="xrStopHapticFeedback"/> + + <type name="XrHapticBaseHeader"/> + <type name="XrHapticActionInfo"/> + </require> + <require comment="Types not directly used by the API"> + <!-- Include <type name="typename"/> here for e.g. structs that + are not parameter types of functions, but still need to be + defined in the API. + --> + <type name="XrFlags64"/> + <type name="XrBool32"/> + + <!-- Utility types to handle polymorphism --> + <type name="XrBaseInStructure"/> + <type name="XrBaseOutStructure"/> + + <!-- Composition layer types used polymorphically by the core spec through XrCompositionLayerBaseHeader. --> + <type name="XrCompositionLayerProjection"/> + <type name="XrCompositionLayerProjectionView"/> + <type name="XrCompositionLayerQuad"/> + + <type name="XrSwapchainSubImage"/> + <type name="XrRect2Di"/> + <type name="XrOffset2Di"/> + <type name="XrExtent2Di"/> + + <!-- Event data types used polymorphically by the core spec through XrEventDataBaseHeader --> + <type name="XrEventDataBaseHeader"/> + <type name="XrEventDataEventsLost"/> + <type name="XrEventDataInstanceLossPending"/> + <type name="XrEventDataSessionStateChanged"/> + <type name="XrEventDataReferenceSpaceChangePending"/> + <type name="XrEventDataInteractionProfileChanged"/> + <type name="XrSessionState"/> + + <!-- Haptic data type used polymorphically by the core spec via XrHapticBaseHeader --> + <type name="XrHapticVibration"/> + + <!-- Unused, but documented types, included for completeness and regularity. --> + <type name="XrOffset2Df"/> + <type name="XrRect2Df"/> + <type name="XrVector4f"/> + + + <!-- Core-like basic data types, documented in core spec, though currently only used by KHR extensions: --> + + <!-- used in XR_KHR_composition_layer_color_scale_bias --> + <type name="XrColor4f"/> + <!-- used in XR_KHR_space bounds --> + <type name="XrExtent2Df"/> + <!-- used in XR_EXT_debug_utils --> + <type name="XrObjectType"/> + </require> + </feature> + + <!-- SECTION: OpenXR Loader API interface definitions --> + <feature api="openxr" name="XR_LOADER_VERSION_1_0" number="1.0"> + <require comment="Negotiate"> + <type name="XR_CURRENT_LOADER_API_LAYER_VERSION"/> + <type name="XR_CURRENT_LOADER_RUNTIME_VERSION"/> + <type name="XR_LOADER_INFO_STRUCT_VERSION"/> + <type name="XR_API_LAYER_INFO_STRUCT_VERSION"/> + <type name="XR_RUNTIME_INFO_STRUCT_VERSION"/> + <type name="XR_API_LAYER_NEXT_INFO_STRUCT_VERSION"/> + <type name="XR_API_LAYER_CREATE_INFO_STRUCT_VERSION"/> + <type name="XR_API_LAYER_MAX_SETTINGS_PATH_SIZE"/> + + <command name="xrCreateApiLayerInstance"/> + <command name="xrNegotiateLoaderRuntimeInterface"/> + <command name="xrNegotiateLoaderApiLayerInterface"/> + + <type name="PFN_xrGetInstanceProcAddr"/> + <type name="PFN_xrCreateApiLayerInstance"/> + <type name="XrLoaderInterfaceStructs"/> + <type name="XrApiLayerCreateInfo"/> + <type name="XrApiLayerNextInfo"/> + <type name="XrNegotiateApiLayerRequest"/> + <type name="XrNegotiateLoaderInfo"/> + <type name="XrNegotiateRuntimeRequest"/> + </require> + </feature> + + <!-- SECTION: OpenXR 1.1 interface definitions --> + + <feature api="openxr" name="XR_VERSION_1_1" number="1.1"> + <require comment="API version"> + <type name="XR_API_VERSION_1_1"/> + </require> + + <require comment="Promoted from XR_KHR_maintenance1"> + + <!-- new structs --> + <type name="XrColor3f"/> + <type name="XrExtent3Df"/> + <type name="XrSpheref"/> + <type name="XrBoxf"/> + <type name="XrFrustumf"/> + + <!-- error codes --> + <enum name="XR_ERROR_EXTENSION_DEPENDENCY_NOT_ENABLED" extends="XrResult" extnumber="711" offset="1" dir="-" comment="One or more of the extensions being enabled has dependency on extensions that are not enabled."/> + <enum name="XR_ERROR_PERMISSION_INSUFFICIENT" extends="XrResult" extnumber="711" offset="0" dir="-" comment="Insufficient permissions. This error is included for use by vendor extensions. The precise definition of `XR_ERROR_PERMISSION_INSUFFICIENT` and actions possible by the developer or user to resolve it can vary by platform, extension or function. The developer should refer to the documentation of the function that returned the error code and extension it was defined."/> + </require> + + <!-- XrUuid --> + <require comment="Promoted from XR_EXT_uuid"> + <enum name="XR_UUID_SIZE"/> + <type name="XrUuid"/> + </require> + + <!-- xrLocateSpaces --> + <require comment="Promoted from XR_KHR_locate_spaces"> + <enum name="XR_TYPE_SPACES_LOCATE_INFO" extends="XrStructureType" extnumber="472" offset="0"/> + <enum name="XR_TYPE_SPACE_LOCATIONS" extends="XrStructureType" extnumber="472" offset="1"/> + <enum name="XR_TYPE_SPACE_VELOCITIES" extends="XrStructureType" extnumber="472" offset="2"/> + + <type name="XrSpacesLocateInfo"/> + <type name="XrSpaceLocationData"/> + <type name="XrSpaceLocations"/> + <type name="XrSpaceVelocityData"/> + <type name="XrSpaceVelocities"/> + + <command name="xrLocateSpaces"/> + </require> + + <!-- XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR --> + <require comment="Promoted from XR_EXT_local_floor"> + <enum name="XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR" extends="XrReferenceSpaceType" extnumber="427" offset="0"/> + </require> + + <!-- grip_surface - promoted version of XR_EXT_palm_pose --> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)"> + <extend interaction_profile_path="/interaction_profiles/khr/simple_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/google/daydream_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/htc/vive_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/microsoft/motion_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/oculus/go_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/oculus/touch_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/valve/index_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/htc/vive_cosmos_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/htc/vive_focus3_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/samsung/odyssey_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/hp/mixed_reality_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/ml/ml2_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_neo3_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico4_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_g3_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_MSFT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/microsoft/hand_interaction"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_HUAWEI_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/huawei/controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_HTC_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/htc/hand_interaction"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_HTCX_vive_tracker_interaction"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_tracker_htcx"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_OPPO_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/oppo/mr_controller_oppo"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_YVR_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/yvr/touch_controller_yvr"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_FB_touch_controller_pro"> + <extend interaction_profile_path="/interaction_profiles/facebook/touch_controller_pro"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_META_touch_controller_plus"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_plus"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_VARJO_xr4_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/varjo/xr-4_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/ext/hand_interaction_ext"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_LOGITECH_mx_ink_stylus_interaction"> + <extend interaction_profile_path="/interaction_profiles/logitech/mx_ink_stylus_logitech"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + <!-- Promote XR_VARJO_quad_views --> + <require comment="Promoted from XR_VARJO_quad_views"> + <enum name="XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO_WITH_FOVEATED_INSET" extends="XrViewConfigurationType" extnumber="38" offset="0"/> + </require> + + + <!-- Promote XR_ML_ml2_controller_interaction --> + <require comment="Promote /interaction_profiles/ml/ml2_controller interaction profile"> + <interaction_profile name="/interaction_profiles/ml/ml2_controller"/> + + <extend interaction_profile_path="/interaction_profiles/ml/ml2_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/ml/ml2_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/ml/ml2_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/ml/ml2_controller"> + <component subpath="/input/trackpad/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_center" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + + <!-- Promote XR_BD_controller_interaction --> + <require comment="Promote XR_BD_controller_interaction"> + <interaction_profile name="/interaction_profiles/bytedance/pico_neo3_controller"/> + <interaction_profile name="/interaction_profiles/bytedance/pico4_controller"/> + <interaction_profile name="/interaction_profiles/bytedance/pico_g3_controller"/> + + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_neo3_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico4_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_g3_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_neo3_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico4_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_g3_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_neo3_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico4_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_g3_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_neo3_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico4_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_g3_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + <!-- Promote XR_HTC_vive_cosmos_controller_interaction --> + <require comment="Promote /interaction_profiles/htc/vive_cosmos_controller interaction profile"> + <interaction_profile name="/interaction_profiles/htc/vive_cosmos_controller"/> + + <extend interaction_profile_path="/interaction_profiles/htc/vive_cosmos_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_cosmos_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_cosmos_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_cosmos_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + <!-- Promote XR_HTC_vive_focus3_controller_interaction --> + <require comment="Promote /interaction_profiles/htc/vive_focus3_controller interaction profile"> + <interaction_profile name="/interaction_profiles/htc/vive_focus3_controller"/> + + <extend interaction_profile_path="/interaction_profiles/htc/vive_focus3_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_focus3_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_focus3_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_focus3_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + <!-- Promote XR_EXT_samsung_odyssey_controller --> + <require comment="Promote /interaction_profiles/samsung/odyssey_controller interaction profile"> + <interaction_profile name="/interaction_profiles/samsung/odyssey_controller"/> + + <extend interaction_profile_path="/interaction_profiles/samsung/odyssey_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/samsung/odyssey_controller"> + <component subpath="/input/trackpad/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_center" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/samsung/odyssey_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/samsung/odyssey_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + <!-- Promote XR_EXT_hp_mixed_reality_controller --> + <require comment="Promote /interaction_profiles/hp/mixed_reality_controller interaction profile"> + <interaction_profile name="/interaction_profiles/hp/mixed_reality_controller"/> + + <extend interaction_profile_path="/interaction_profiles/hp/mixed_reality_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/hp/mixed_reality_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/hp/mixed_reality_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/hp/mixed_reality_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + <!-- Promote XR_FB_touch_controller_pro --> + <require comment="Promote (and rename) /interaction_profiles/facebook/touch_controller_pro interaction profile"> + <interaction_profile name="/interaction_profiles/meta/touch_pro_controller"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_pro_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_pro_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_pro_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + <!-- Promote XR_META_touch_controller_plus --> + <require comment="Promote (and rename) /interaction_profiles/meta/touch_controller_plus interaction profile"> + <interaction_profile name="/interaction_profiles/meta/touch_plus_controller"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_plus_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_plus_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_plus_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + <!-- Promote Meta legacy touch controller profiles --> + <require comment="Promote legacy touch_controller profiles"> + <interaction_profile name="/interaction_profiles/meta/touch_controller_rift_cv1"/> + <interaction_profile name="/interaction_profiles/meta/touch_controller_quest_1_rift_s"/> + <interaction_profile name="/interaction_profiles/meta/touch_controller_quest_2"/> + </require> + + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_rift_cv1"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_quest_1_rift_s"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_quest_2"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_rift_cv1"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_quest_1_rift_s"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_quest_2"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_rift_cv1"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_quest_1_rift_s"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_quest_2"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + + <!-- Promote XR_FB_touch_controller_proximity --> + <require comment="Promote XR_FB_touch_controller_proximity interaction profile paths"> + <extend interaction_profile_path="/interaction_profiles/oculus/touch_controller"> + <component subpath="/input/trigger/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumb_resting_surfaces/proximity" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + + </feature> + + <!-- SECTION: OpenXR extension interface definitions --> + <extensions> + <!-- Android Thread Settings extension --> + <extension name="XR_KHR_android_thread_settings" number="4" type="instance" supported="openxr" protect="XR_USE_PLATFORM_ANDROID" ratified="openxr"> + <require> + <enum value="6" name="XR_KHR_android_thread_settings_SPEC_VERSION"/> + <enum value=""XR_KHR_android_thread_settings"" name="XR_KHR_ANDROID_THREAD_SETTINGS_EXTENSION_NAME"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_ANDROID_THREAD_SETTINGS_ID_INVALID_KHR" comment="xrSetAndroidApplicationThreadKHR failed as thread id is invalid."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_ANDROID_THREAD_SETTINGS_FAILURE_KHR" comment="xrSetAndroidApplicationThreadKHR failed setting the thread attributes/priority."/> + <type name="XrAndroidThreadTypeKHR"/> + <command name="xrSetAndroidApplicationThreadKHR"/> + </require> + </extension> + + <!-- Android Surface Swapchain extension --> + <extension name="XR_KHR_android_surface_swapchain" number="5" type="instance" supported="openxr" protect="XR_USE_PLATFORM_ANDROID" ratified="openxr"> + <require> + <enum value="4" name="XR_KHR_android_surface_swapchain_SPEC_VERSION"/> + <enum value=""XR_KHR_android_surface_swapchain"" name="XR_KHR_ANDROID_SURFACE_SWAPCHAIN_EXTENSION_NAME"/> + <command name="xrCreateSwapchainAndroidSurfaceKHR"/> + </require> + </extension> + + <!-- Non-core composition cube layer --> + <extension name="XR_KHR_composition_layer_cube" number="7" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="8" name="XR_KHR_composition_layer_cube_SPEC_VERSION"/> + <enum value=""XR_KHR_composition_layer_cube"" name="XR_KHR_COMPOSITION_LAYER_CUBE_EXTENSION_NAME"/> + <type name="XrCompositionLayerCubeKHR"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_CUBE_KHR"/> + </require> + </extension> + + <!-- Android Create Instance extension --> + <extension name="XR_KHR_android_create_instance" number="9" type="instance" supported="openxr" protect="XR_USE_PLATFORM_ANDROID" ratified="openxr"> + <require> + <enum value="3" name="XR_KHR_android_create_instance_SPEC_VERSION"/> + <enum value=""XR_KHR_android_create_instance"" name="XR_KHR_ANDROID_CREATE_INSTANCE_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_INSTANCE_CREATE_INFO_ANDROID_KHR"/> + <type name="XrInstanceCreateInfoAndroidKHR"/> + </require> + </extension> + + <!-- Runtime support for additional per-layer depth info --> + <extension name="XR_KHR_composition_layer_depth" number="11" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="6" name="XR_KHR_composition_layer_depth_SPEC_VERSION"/> + <enum value=""XR_KHR_composition_layer_depth"" name="XR_KHR_COMPOSITION_LAYER_DEPTH_EXTENSION_NAME"/> + <type name="XrCompositionLayerDepthInfoKHR"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_DEPTH_INFO_KHR"/> + </require> + </extension> + + <!-- Reserved for headless "graphics binding" extension --> + <extension name="XR_KHR_headless" number="14" type="instance" supported="disabled"> + <require> + <enum value="4" name="XR_KHR_headless_SPEC_VERSION"/> + <enum value=""XR_KHR_headless"" name="XR_KHR_HEADLESS_EXTENSION_NAME"/> + </require> + </extension> + + + <!-- Vulkan image format list extension --> + <extension name="XR_KHR_vulkan_swapchain_format_list" number="15" type="instance" depends="XR_VERSION_1_0+XR_KHR_vulkan_enable,XR_VERSION_1_0+XR_KHR_vulkan_enable2" supported="openxr" protect="XR_USE_GRAPHICS_API_VULKAN" ratified="openxr"> + <require> + <enum value="5" name="XR_KHR_vulkan_swapchain_format_list_SPEC_VERSION"/> + <enum value=""XR_KHR_vulkan_swapchain_format_list"" name="XR_KHR_VULKAN_SWAPCHAIN_FORMAT_LIST_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_VULKAN_SWAPCHAIN_FORMAT_LIST_CREATE_INFO_KHR"/> + <type name="XrVulkanSwapchainFormatListCreateInfoKHR"/> + </require> + </extension> + + <!-- Performance Settings extension --> + <extension name="XR_EXT_performance_settings" number="16" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="4" name="XR_EXT_performance_settings_SPEC_VERSION"/> + <enum value=""XR_EXT_performance_settings"" name="XR_EXT_PERFORMANCE_SETTINGS_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_PERF_SETTINGS_EXT"/> + <type name="XrPerfSettingsDomainEXT"/> + <type name="XrPerfSettingsSubDomainEXT"/> + <type name="XrPerfSettingsLevelEXT"/> + <type name="XrPerfSettingsNotificationLevelEXT"/> + <type name="XrEventDataPerfSettingsEXT"/> + <command name="xrPerfSettingsSetPerformanceLevelEXT"/> + </require> + </extension> + + <!-- Thermal Query extension --> + <extension name="XR_EXT_thermal_query" number="17" type="instance" supported="openxr"> + <require> + <enum value="2" name="XR_EXT_thermal_query_SPEC_VERSION"/> + <enum value=""XR_EXT_thermal_query"" name="XR_EXT_THERMAL_QUERY_EXTENSION_NAME"/> + <type name="XrPerfSettingsDomainEXT"/> + <type name="XrPerfSettingsNotificationLevelEXT"/> + <command name="xrThermalGetTemperatureTrendEXT"/> + </require> + </extension> + + <!-- Non-core composition cylinder layer --> + <extension name="XR_KHR_composition_layer_cylinder" number="18" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="4" name="XR_KHR_composition_layer_cylinder_SPEC_VERSION"/> + <enum value=""XR_KHR_composition_layer_cylinder"" name="XR_KHR_COMPOSITION_LAYER_CYLINDER_EXTENSION_NAME"/> + <type name="XrCompositionLayerCylinderKHR"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_CYLINDER_KHR"/> + </require> + </extension> + + <!-- Non-core composition equilateral rect layer --> + <extension name="XR_KHR_composition_layer_equirect" number="19" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="3" name="XR_KHR_composition_layer_equirect_SPEC_VERSION"/> + <enum value=""XR_KHR_composition_layer_equirect"" name="XR_KHR_COMPOSITION_LAYER_EQUIRECT_EXTENSION_NAME"/> + <type name="XrCompositionLayerEquirectKHR"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_EQUIRECT_KHR"/> + </require> + </extension> + + <!-- Debug Utilities extension --> + <extension name="XR_EXT_debug_utils" number="20" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="5" name="XR_EXT_debug_utils_SPEC_VERSION"/> + <enum value=""XR_EXT_debug_utils"" name="XR_EXT_DEBUG_UTILS_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_DEBUG_UTILS_LABEL_EXT"/> + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT" comment="XrDebugUtilsMessengerEXT"/> + <type name="PFN_xrDebugUtilsMessengerCallbackEXT"/> + <type name="XrDebugUtilsObjectNameInfoEXT"/> + <type name="XrDebugUtilsLabelEXT"/> + <type name="XrDebugUtilsMessengerEXT"/> + <type name="XrDebugUtilsMessengerCallbackDataEXT"/> + <type name="XrDebugUtilsMessengerCreateInfoEXT"/> + <type name="XrDebugUtilsMessageTypeFlagsEXT"/> + <type name="XrDebugUtilsMessageTypeFlagBitsEXT"/> + <type name="XrDebugUtilsMessageSeverityFlagsEXT"/> + <type name="XrDebugUtilsMessageSeverityFlagBitsEXT"/> + <command name="xrSetDebugUtilsObjectNameEXT"/> + <command name="xrCreateDebugUtilsMessengerEXT"/> + <command name="xrDestroyDebugUtilsMessengerEXT"/> + <command name="xrSubmitDebugUtilsMessageEXT"/> + <command name="xrSessionBeginDebugUtilsLabelRegionEXT"/> + <command name="xrSessionEndDebugUtilsLabelRegionEXT"/> + <command name="xrSessionInsertDebugUtilsLabelEXT"/> + </require> + </extension> + + <!-- Reserved space for Variable rate rendering extension --> + <extension name="XR_KHR_variable_rate_rendering" number="21" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_KHR_variable_rate_rendering_SPEC_VERSION"/> + <enum value=""XR_KHR_variable_rate_rendering"" name="XR_KHR_VARIABLE_RATE_RENDERING_EXTENSION_NAME"/> + </require> + </extension> + + <!-- Reserved space for Overlays extension --> + <extension name="XR_KHR_overlays" number="22" type="instance" supported="disabled"> + <require> + <enum value="0" name="XR_KHR_overlays_SPEC_VERSION"/> + <enum value=""XR_KHR_overlays"" name="XR_KHR_OVERLAYS_EXTENSION_NAME"/> + </require> + </extension> + + <!-- OpenGL graphics binding extension --> + <extension name="XR_KHR_opengl_enable" number="24" type="instance" protect="XR_USE_GRAPHICS_API_OPENGL" supported="openxr" ratified="openxr"> + <require> + <enum value="12" name="XR_KHR_opengl_enable_SPEC_VERSION"/> + <enum value=""XR_KHR_opengl_enable"" name="XR_KHR_OPENGL_ENABLE_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_GRAPHICS_BINDING_OPENGL_WIN32_KHR"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_GRAPHICS_BINDING_OPENGL_XLIB_KHR"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_GRAPHICS_BINDING_OPENGL_XCB_KHR"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_GRAPHICS_BINDING_OPENGL_WAYLAND_KHR"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_KHR"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_KHR"/> + <type name="XrGraphicsBindingOpenGLWin32KHR"/> + <type name="XrGraphicsBindingOpenGLXlibKHR"/> + <type name="XrGraphicsBindingOpenGLXcbKHR"/> + <type name="XrGraphicsBindingOpenGLWaylandKHR"/> + <type name="XrSwapchainImageOpenGLKHR"/> + <type name="XrGraphicsRequirementsOpenGLKHR"/> + <command name="xrGetOpenGLGraphicsRequirementsKHR"/> + </require> + </extension> + + <!-- OpenGL ES graphics binding extension --> + <extension name="XR_KHR_opengl_es_enable" number="25" type="instance" protect="XR_USE_GRAPHICS_API_OPENGL_ES" supported="openxr" ratified="openxr"> + <require> + <enum value="10" name="XR_KHR_opengl_es_enable_SPEC_VERSION"/> + <enum value=""XR_KHR_opengl_es_enable"" name="XR_KHR_OPENGL_ES_ENABLE_EXTENSION_NAME"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_GRAPHICS_BINDING_OPENGL_ES_ANDROID_KHR"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_IMAGE_OPENGL_ES_KHR"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_GRAPHICS_REQUIREMENTS_OPENGL_ES_KHR"/> + <type name="XrGraphicsBindingOpenGLESAndroidKHR"/> + <type name="XrSwapchainImageOpenGLESKHR"/> + <type name="XrGraphicsRequirementsOpenGLESKHR"/> + <command name="xrGetOpenGLESGraphicsRequirementsKHR"/> + </require> + </extension> + + <!-- Vulkan graphics binding extension --> + <extension name="XR_KHR_vulkan_enable" number="26" type="instance" protect="XR_USE_GRAPHICS_API_VULKAN" supported="openxr" ratified="openxr"> + <require> + <enum value="10" name="XR_KHR_vulkan_enable_SPEC_VERSION"/> + <enum value=""XR_KHR_vulkan_enable"" name="XR_KHR_VULKAN_ENABLE_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR"/> + <type name="XrGraphicsBindingVulkanKHR"/> + <type name="XrSwapchainImageVulkanKHR"/> + <type name="XrGraphicsRequirementsVulkanKHR"/> + <command name="xrGetVulkanInstanceExtensionsKHR"/> + <command name="xrGetVulkanDeviceExtensionsKHR"/> + <command name="xrGetVulkanGraphicsDeviceKHR"/> + <command name="xrGetVulkanGraphicsRequirementsKHR"/> + </require> + </extension> + + <!-- Value used by obsolete D3D10 graphics binding extension --> + <extension name="XR_KHR_D3D10_enable_obsolete" number="27" type="instance" supported="disabled"> + <require> + <enum value="4" name="XR_KHR_D3D10_enable_obsolete_SPEC_VERSION"/> + <enum value=""XR_KHR_D3D10_enable_obsolete"" name="XR_KHR_D3D10_ENABLE_OBSOLETE_EXTENSION_NAME"/> + </require> + </extension> + + <!-- D3D11 graphics binding extension --> + <extension name="XR_KHR_D3D11_enable" number="28" type="instance" protect="XR_USE_GRAPHICS_API_D3D11" supported="openxr" ratified="openxr"> + <require> + <enum value="11" name="XR_KHR_D3D11_enable_SPEC_VERSION"/> + <enum value=""XR_KHR_D3D11_enable"" name="XR_KHR_D3D11_ENABLE_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_GRAPHICS_BINDING_D3D11_KHR"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_IMAGE_D3D11_KHR"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_GRAPHICS_REQUIREMENTS_D3D11_KHR"/> + <type name="XrGraphicsBindingD3D11KHR"/> + <type name="XrSwapchainImageD3D11KHR"/> + <type name="XrGraphicsRequirementsD3D11KHR"/> + <command name="xrGetD3D11GraphicsRequirementsKHR"/> + </require> + </extension> + + <!-- D3D12 graphics binding extension --> + <extension name="XR_KHR_D3D12_enable" number="29" type="instance" protect="XR_USE_GRAPHICS_API_D3D12" supported="openxr" ratified="openxr"> + <require> + <enum value="11" name="XR_KHR_D3D12_enable_SPEC_VERSION"/> + <enum value=""XR_KHR_D3D12_enable"" name="XR_KHR_D3D12_ENABLE_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_GRAPHICS_BINDING_D3D12_KHR"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_IMAGE_D3D12_KHR"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_GRAPHICS_REQUIREMENTS_D3D12_KHR"/> + <type name="XrGraphicsBindingD3D12KHR"/> + <type name="XrSwapchainImageD3D12KHR"/> + <type name="XrGraphicsRequirementsD3D12KHR"/> + <command name="xrGetD3D12GraphicsRequirementsKHR"/> + </require> + </extension> + + <!-- Metal graphics binding extension --> + <extension name="XR_KHR_metal_enable" number="30" type="instance" protect="XR_USE_GRAPHICS_API_METAL" supported="openxr" ratified="openxr"> + <require> + <enum value="3" name="XR_KHR_metal_enable_SPEC_VERSION"/> + <enum value=""XR_KHR_metal_enable"" name="XR_KHR_METAL_ENABLE_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_GRAPHICS_BINDING_METAL_KHR"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_IMAGE_METAL_KHR"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_GRAPHICS_REQUIREMENTS_METAL_KHR"/> + <type name="XrGraphicsBindingMetalKHR"/> + <type name="XrSwapchainImageMetalKHR"/> + <type name="XrGraphicsRequirementsMetalKHR"/> + <command name="xrGetMetalGraphicsRequirementsKHR"/> + </require> + </extension> + + <!-- Eye gaze interaction extension --> + <extension name="XR_EXT_eye_gaze_interaction" number="31" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="2" name="XR_EXT_eye_gaze_interaction_SPEC_VERSION"/> + <enum value=""XR_EXT_eye_gaze_interaction"" name="XR_EXT_EYE_GAZE_INTERACTION_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_EYE_GAZE_INTERACTION_PROPERTIES_EXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_EYE_GAZE_SAMPLE_TIME_EXT"/> + <type name="XrSystemEyeGazeInteractionPropertiesEXT"/> + <type name="XrEyeGazeSampleTimeEXT"/> + + <interaction_profile name="/interaction_profiles/ext/eye_gaze_interaction"/> + </require> + </extension> + + <!-- Visibility mask extension --> + <extension name="XR_KHR_visibility_mask" number="32" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="2" name="XR_KHR_visibility_mask_SPEC_VERSION"/> + <enum value=""XR_KHR_visibility_mask"" name="XR_KHR_VISIBILITY_MASK_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_VISIBILITY_MASK_KHR"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_VISIBILITY_MASK_CHANGED_KHR"/> + <type name="XrVisibilityMaskTypeKHR"/> + <type name="XrVisibilityMaskKHR"/> + <type name="XrEventDataVisibilityMaskChangedKHR"/> + <command name="xrGetVisibilityMaskKHR"/> + </require> + </extension> + + <!-- Reserved space for EXT permissions support --> + <extension name="XR_EXT_permissions_support" number="33" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_permissions_support_SPEC_VERSION"/> + <enum value=""XR_EXT_permissions_support"" name="XR_EXT_PERMISSIONS_SUPPORT_EXTENSION_NAME"/> + </require> + </extension> + + <!-- Overlay preview extension --> + <extension name="XR_EXTX_overlay" number="34" type="instance" provisional="true" supported="openxr"> + <require> + <enum value="5" name="XR_EXTX_overlay_SPEC_VERSION"/> + <enum value=""XR_EXTX_overlay"" name="XR_EXTX_OVERLAY_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SESSION_CREATE_INFO_OVERLAY_EXTX"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_MAIN_SESSION_VISIBILITY_CHANGED_EXTX"/> + <type name="XrSessionCreateInfoOverlayEXTX"/> + <type name="XrEventDataMainSessionVisibilityChangedEXTX"/> + <type name="XrOverlayMainSessionFlagsEXTX"/> + <type name="XrOverlayMainSessionFlagBitsEXTX"/> + <type name="XrOverlaySessionCreateFlagsEXTX"/> + <type name="XrOverlaySessionCreateFlagBitsEXTX"/> + </require> + </extension> + + + <!-- per-layer color scale and bias --> + <extension name="XR_KHR_composition_layer_color_scale_bias" number="35" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="5" name="XR_KHR_composition_layer_color_scale_bias_SPEC_VERSION"/> + <enum value=""XR_KHR_composition_layer_color_scale_bias"" name="XR_KHR_COMPOSITION_LAYER_COLOR_SCALE_BIAS_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_COLOR_SCALE_BIAS_KHR"/> + <type name="XrCompositionLayerColorScaleBiasKHR"/> + </require> + </extension> + + <extension name="XR_KHR_win32_convert_performance_counter_time" number="36" type="instance" supported="openxr" protect="XR_USE_PLATFORM_WIN32" ratified="openxr"> + <require> + <enum value="1" name="XR_KHR_win32_convert_performance_counter_time_SPEC_VERSION"/> + <enum value=""XR_KHR_win32_convert_performance_counter_time"" name="XR_KHR_WIN32_CONVERT_PERFORMANCE_COUNTER_TIME_EXTENSION_NAME"/> + <command name="xrConvertWin32PerformanceCounterToTimeKHR"/> + <command name="xrConvertTimeToWin32PerformanceCounterKHR"/> + </require> + </extension> + + <extension name="XR_KHR_convert_timespec_time" number="37" type="instance" supported="openxr" protect="XR_USE_TIMESPEC" ratified="openxr"> + <require> + <enum value="1" name="XR_KHR_convert_timespec_time_SPEC_VERSION"/> + <enum value=""XR_KHR_convert_timespec_time"" name="XR_KHR_CONVERT_TIMESPEC_TIME_EXTENSION_NAME"/> + <command name="xrConvertTimespecTimeToTimeKHR"/> + <command name="xrConvertTimeToTimespecTimeKHR"/> + </require> + </extension> + + <extension name="XR_VARJO_quad_views" number="38" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="2" name="XR_VARJO_quad_views_SPEC_VERSION"/> + <enum value=""XR_VARJO_quad_views"" name="XR_VARJO_QUAD_VIEWS_EXTENSION_NAME"/> + <enum extends="XrViewConfigurationType" name="XR_VIEW_CONFIGURATION_TYPE_PRIMARY_QUAD_VARJO" alias="XR_VIEW_CONFIGURATION_TYPE_PRIMARY_STEREO_WITH_FOVEATED_INSET"/> + </require> + </extension> + + <extension name="XR_MSFT_unbounded_reference_space" number="39" type="instance" supported="openxr" deprecatedby=""> + <require> + <enum value="1" name="XR_MSFT_unbounded_reference_space_SPEC_VERSION"/> + <enum value=""XR_MSFT_unbounded_reference_space"" name="XR_MSFT_UNBOUNDED_REFERENCE_SPACE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrReferenceSpaceType" name="XR_REFERENCE_SPACE_TYPE_UNBOUNDED_MSFT"/> + </require> + </extension> + + <extension name="XR_MSFT_spatial_anchor" number="40" type="instance" supported="openxr" obsoletedby="XR_EXT_spatial_anchor"> + <require> + <enum value="2" name="XR_MSFT_spatial_anchor_SPEC_VERSION"/> + <enum value=""XR_MSFT_spatial_anchor"" name="XR_MSFT_SPATIAL_ANCHOR_EXTENSION_NAME"/> + + <type name="XrSpatialAnchorMSFT"/> + <type name="XrSpatialAnchorCreateInfoMSFT"/> + <type name="XrSpatialAnchorSpaceCreateInfoMSFT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_MSFT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_SPACE_CREATE_INFO_MSFT"/> + <command name="xrCreateSpatialAnchorMSFT"/> + <command name="xrCreateSpatialAnchorSpaceMSFT"/> + <command name="xrDestroySpatialAnchorMSFT"/> + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SPATIAL_ANCHOR_MSFT" comment="XrSpatialAnchorMSFT"/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_CREATE_SPATIAL_ANCHOR_FAILED_MSFT" comment="Spatial anchor could not be created at that location."/> + </require> + </extension> + + <extension name="XR_FB_composition_layer_image_layout" number="41" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_composition_layer_image_layout_SPEC_VERSION"/> + <enum value=""XR_FB_composition_layer_image_layout"" name="XR_FB_COMPOSITION_LAYER_IMAGE_LAYOUT_EXTENSION_NAME"/> + <type name="XrCompositionLayerImageLayoutFB"/> + <type name="XrCompositionLayerImageLayoutFlagsFB"/> + <type name="XrCompositionLayerImageLayoutFlagBitsFB"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_IMAGE_LAYOUT_FB"/> + </require> + </extension> + + <extension name="XR_FB_composition_layer_alpha_blend" number="42" type="instance" supported="openxr"> + <require> + <enum value="3" name="XR_FB_composition_layer_alpha_blend_SPEC_VERSION"/> + <enum value=""XR_FB_composition_layer_alpha_blend"" name="XR_FB_COMPOSITION_LAYER_ALPHA_BLEND_EXTENSION_NAME"/> + <type name="XrBlendFactorFB"/> + <type name="XrCompositionLayerAlphaBlendFB"/> + <type name="XrCompositionLayerSecureContentFlagsFB"/> + <type name="XrCompositionLayerSecureContentFlagBitsFB"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_ALPHA_BLEND_FB"/> + </require> + </extension> + + <extension name="XR_MND_headless" number="43" type="instance" supported="openxr"> + <require> + <enum value="3" name="XR_MND_headless_SPEC_VERSION"/> + <enum value=""XR_MND_headless"" name="XR_MND_HEADLESS_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_OCULUS_extension_44" number="44" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_OCULUS_extension_44_SPEC_VERSION"/> + <enum value=""XR_OCULUS_extension_44"" name="XR_OCULUS_EXTENSION_44_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_OCULUS_android_session_state_enable" number="45" type="instance" supported="openxr" deprecatedby=""> + <require> + <enum value="1" name="XR_OCULUS_android_session_state_enable_SPEC_VERSION"/> + <enum value=""XR_OCULUS_android_session_state_enable"" name="XR_OCULUS_ANDROID_SESSION_STATE_ENABLE_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_46" number="46" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_46_SPEC_VERSION"/> + <enum value=""XR_MND_extension_46"" name="XR_MND_EXTENSION_46_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_view_configuration_depth_range" number="47" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_view_configuration_depth_range_SPEC_VERSION"/> + <enum value=""XR_EXT_view_configuration_depth_range"" name="XR_EXT_VIEW_CONFIGURATION_DEPTH_RANGE_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_VIEW_CONFIGURATION_DEPTH_RANGE_EXT"/> + <type name="XrViewConfigurationDepthRangeEXT"/> + </require> + </extension> + + <extension name="XR_EXT_conformance_automation" number="48" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="3" name="XR_EXT_conformance_automation_SPEC_VERSION"/> + <enum value=""XR_EXT_conformance_automation"" name="XR_EXT_CONFORMANCE_AUTOMATION_EXTENSION_NAME"/> + <command name="xrSetInputDeviceActiveEXT"/> + <command name="xrSetInputDeviceStateBoolEXT"/> + <command name="xrSetInputDeviceStateFloatEXT"/> + <command name="xrSetInputDeviceStateVector2fEXT"/> + <command name="xrSetInputDeviceLocationEXT"/> + </require> + </extension> + + <extension name="XR_MNDX_egl_enable" number="49" type="instance" provisional="true" protect="XR_USE_PLATFORM_EGL" supported="openxr"> + <require> + <enum value="2" name="XR_MNDX_egl_enable_SPEC_VERSION"/> + <enum value=""XR_MNDX_egl_enable"" name="XR_MNDX_EGL_ENABLE_EXTENSION_NAME"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_GRAPHICS_BINDING_EGL_MNDX"/> + <type name="PFN_xrEglGetProcAddressMNDX"/> + <type name="XrGraphicsBindingEGLMNDX"/> + </require> + </extension> + + <extension name="XR_MSFT_spatial_graph_bridge" number="50" type="instance" supported="openxr" deprecatedby=""> + <require> + <enum value="2" name="XR_MSFT_spatial_graph_bridge_SPEC_VERSION"/> + <enum value=""XR_MSFT_spatial_graph_bridge"" name="XR_MSFT_SPATIAL_GRAPH_BRIDGE_EXTENSION_NAME"/> + <type name="XrSpatialGraphNodeBindingMSFT"/> + <type name="XrSpatialGraphNodeTypeMSFT"/> + <type name="XrSpatialGraphNodeSpaceCreateInfoMSFT"/> + <type name="XrSpatialGraphStaticNodeBindingCreateInfoMSFT"/> + <type name="XrSpatialGraphNodeBindingPropertiesGetInfoMSFT"/> + <type name="XrSpatialGraphNodeBindingPropertiesMSFT"/> + <command name="xrCreateSpatialGraphNodeSpaceMSFT"/> + <command name="xrTryCreateSpatialGraphStaticNodeBindingMSFT"/> + <command name="xrDestroySpatialGraphNodeBindingMSFT"/> + <command name="xrGetSpatialGraphNodeBindingPropertiesMSFT"/> + <enum value="16" name="XR_GUID_SIZE_MSFT"/> + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SPATIAL_GRAPH_NODE_BINDING_MSFT" comment="XrSpatialGraphNodeBindingMSFT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_GRAPH_NODE_SPACE_CREATE_INFO_MSFT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_GRAPH_STATIC_NODE_BINDING_CREATE_INFO_MSFT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_GET_INFO_MSFT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPATIAL_GRAPH_NODE_BINDING_PROPERTIES_MSFT"/> + </require> + </extension> + + <extension name="XR_MSFT_hand_interaction" number="51" type="instance" supported="openxr" promotedto="XR_EXT_hand_interaction"> + <require> + <enum value="1" name="XR_MSFT_hand_interaction_SPEC_VERSION"/> + <enum value=""XR_MSFT_hand_interaction"" name="XR_MSFT_HAND_INTERACTION_EXTENSION_NAME"/> + + <interaction_profile name="/interaction_profiles/microsoft/hand_interaction"/> + </require> + + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/microsoft/hand_interaction"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/microsoft/hand_interaction"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_EXT_hand_tracking" number="52" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="4" name="XR_EXT_hand_tracking_SPEC_VERSION"/> + <enum value=""XR_EXT_hand_tracking"" name="XR_EXT_HAND_TRACKING_EXTENSION_NAME"/> + + <command name="xrCreateHandTrackerEXT"/> + <command name="xrDestroyHandTrackerEXT"/> + <command name="xrLocateHandJointsEXT"/> + + <type name="XrHandEXT"/> + <type name="XrHandJointEXT"/> + <type name="XrHandJointSetEXT"/> + + <type name="XrHandTrackerEXT"/> + <type name="XrSystemHandTrackingPropertiesEXT"/> + <type name="XrHandTrackerCreateInfoEXT"/> + <type name="XrHandJointsLocateInfoEXT"/> + <type name="XrHandJointLocationEXT"/> + <type name="XrHandJointVelocityEXT"/> + <type name="XrHandJointLocationsEXT"/> + <type name="XrHandJointVelocitiesEXT"/> + <type name="XR_HAND_JOINT_COUNT_EXT"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_HAND_TRACKER_EXT" comment="XrHandTrackerEXT"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_HAND_TRACKING_PROPERTIES_EXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_HAND_TRACKER_CREATE_INFO_EXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_HAND_JOINTS_LOCATE_INFO_EXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_HAND_JOINT_LOCATIONS_EXT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_HAND_JOINT_VELOCITIES_EXT"/> + </require> + </extension> + + <extension name="XR_MSFT_hand_tracking_mesh" number="53" depends="XR_VERSION_1_0+XR_EXT_hand_tracking" type="instance" supported="openxr" deprecatedby=""> + <require> + <enum value="4" name="XR_MSFT_hand_tracking_mesh_SPEC_VERSION"/> + <enum value=""XR_MSFT_hand_tracking_mesh"" name="XR_MSFT_HAND_TRACKING_MESH_EXTENSION_NAME"/> + + <command name="xrCreateHandMeshSpaceMSFT"/> + <command name="xrUpdateHandMeshMSFT"/> + + <type name="XrSystemHandTrackingMeshPropertiesMSFT"/> + <type name="XrHandMeshSpaceCreateInfoMSFT"/> + <type name="XrHandMeshUpdateInfoMSFT"/> + <type name="XrHandMeshMSFT"/> + <type name="XrHandMeshIndexBufferMSFT"/> + <type name="XrHandMeshVertexBufferMSFT"/> + <type name="XrHandMeshVertexMSFT"/> + <type name="XrHandPoseTypeMSFT"/> + <type name="XrHandPoseTypeInfoMSFT"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_HAND_TRACKING_MESH_PROPERTIES_MSFT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_HAND_MESH_SPACE_CREATE_INFO_MSFT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_HAND_MESH_UPDATE_INFO_MSFT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_HAND_MESH_MSFT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_HAND_POSE_TYPE_INFO_MSFT"/> + </require> + </extension> + + <extension name="XR_MSFT_secondary_view_configuration" number="54" type="instance" supported="openxr" deprecatedby=""> + <require> + <enum value="1" name="XR_MSFT_secondary_view_configuration_SPEC_VERSION"/> + <enum value=""XR_MSFT_secondary_view_configuration"" name="XR_MSFT_SECONDARY_VIEW_CONFIGURATION_EXTENSION_NAME"/> + <type name="XrSecondaryViewConfigurationSessionBeginInfoMSFT"/> + <type name="XrSecondaryViewConfigurationStateMSFT"/> + <type name="XrSecondaryViewConfigurationFrameStateMSFT"/> + <type name="XrSecondaryViewConfigurationFrameEndInfoMSFT"/> + <type name="XrSecondaryViewConfigurationLayerInfoMSFT"/> + <type name="XrSecondaryViewConfigurationSwapchainCreateInfoMSFT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_SESSION_BEGIN_INFO_MSFT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_STATE_MSFT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_FRAME_STATE_MSFT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_FRAME_END_INFO_MSFT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_LAYER_INFO_MSFT"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_SECONDARY_VIEW_CONFIGURATION_SWAPCHAIN_CREATE_INFO_MSFT"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SECONDARY_VIEW_CONFIGURATION_TYPE_NOT_ENABLED_MSFT" comment="The secondary view configuration was not enabled when creating the session."/> + </require> + </extension> + + <extension name="XR_MSFT_first_person_observer" number="55" type="instance" depends="XR_VERSION_1_0+XR_MSFT_secondary_view_configuration" supported="openxr" deprecatedby=""> + <require> + <enum value="1" name="XR_MSFT_first_person_observer_SPEC_VERSION"/> + <enum value=""XR_MSFT_first_person_observer"" name="XR_MSFT_FIRST_PERSON_OBSERVER_EXTENSION_NAME"/> + <enum offset="0" extends="XrViewConfigurationType" name="XR_VIEW_CONFIGURATION_TYPE_SECONDARY_MONO_FIRST_PERSON_OBSERVER_MSFT"/> + </require> + </extension> + + <extension name="XR_MSFT_controller_model" number="56" type="instance" supported="openxr" obsoletedby="XR_EXT_interaction_render_model"> + <require> + <enum value="2" name="XR_MSFT_controller_model_SPEC_VERSION"/> + <enum value=""XR_MSFT_controller_model"" name="XR_MSFT_CONTROLLER_MODEL_EXTENSION_NAME"/> + + <type name="XrControllerModelKeyStateMSFT"/> + <type name="XrControllerModelNodePropertiesMSFT"/> + <type name="XrControllerModelPropertiesMSFT"/> + <type name="XrControllerModelNodeStateMSFT"/> + <type name="XrControllerModelStateMSFT"/> + <type name="XrControllerModelKeyMSFT"/> + <type name="XR_NULL_CONTROLLER_MODEL_KEY_MSFT"/> + + <command name="xrGetControllerModelKeyMSFT"/> + <command name="xrLoadControllerModelMSFT"/> + <command name="xrGetControllerModelPropertiesMSFT"/> + <command name="xrGetControllerModelStateMSFT"/> + + <enum value="64" name="XR_MAX_CONTROLLER_MODEL_NODE_NAME_SIZE_MSFT"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_CONTROLLER_MODEL_KEY_STATE_MSFT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_CONTROLLER_MODEL_NODE_PROPERTIES_MSFT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_CONTROLLER_MODEL_PROPERTIES_MSFT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_CONTROLLER_MODEL_NODE_STATE_MSFT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_CONTROLLER_MODEL_STATE_MSFT"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_CONTROLLER_MODEL_KEY_INVALID_MSFT" comment="The controller model key is invalid."/> + + </require> + </extension> + + <extension name="XR_MSFT_perception_anchor_interop" number="57" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_MSFT_spatial_anchor" protect="XR_USE_PLATFORM_WIN32" deprecatedby=""> + <require> + <enum value="1" name="XR_MSFT_perception_anchor_interop_SPEC_VERSION"/> + <enum value=""XR_MSFT_perception_anchor_interop"" name="XR_MSFT_PERCEPTION_ANCHOR_INTEROP_EXTENSION_NAME"/> + + <command name="xrCreateSpatialAnchorFromPerceptionAnchorMSFT"/> + <command name="xrTryGetPerceptionAnchorFromSpatialAnchorMSFT"/> + + </require> + </extension> + + <extension name="XR_EXT_win32_appcontainer_compatible" number="58" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_EXT_win32_appcontainer_compatible_SPEC_VERSION"/> + <enum value=""XR_EXT_win32_appcontainer_compatible"" name="XR_EXT_WIN32_APPCONTAINER_COMPATIBLE_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_59" number="59" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_59_SPEC_VERSION"/> + <enum value=""XR_ML_extension_59"" name="XR_ML_extension_59_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EPIC_view_configuration_fov" number="60" type="instance" supported="openxr"> + <require> + <enum value="2" name="XR_EPIC_view_configuration_fov_SPEC_VERSION"/> + <enum value=""XR_EPIC_view_configuration_fov"" name="XR_EPIC_VIEW_CONFIGURATION_FOV_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_VIEW_CONFIGURATION_VIEW_FOV_EPIC"/> + <type name="XrViewConfigurationViewFovEPIC"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_63" number="63" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_63_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_63"" name="XR_MSFT_extension_63_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_holographic_window_attachment" number="64" type="instance" supported="openxr" protect="XR_USE_PLATFORM_WIN32" deprecatedby=""> + <require> + <enum value="1" name="XR_MSFT_holographic_window_attachment_SPEC_VERSION"/> + <enum value=""XR_MSFT_holographic_window_attachment"" name="XR_MSFT_HOLOGRAPHIC_WINDOW_ATTACHMENT_EXTENSION_NAME"/> + <type name="XrHolographicWindowAttachmentMSFT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_HOLOGRAPHIC_WINDOW_ATTACHMENT_MSFT"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_65" number="65" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_65_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_65"" name="XR_MSFT_extension_65_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_66" number="66" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_66_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_66"" name="XR_MSFT_extension_66_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_composition_layer_reprojection" number="67" type="instance" supported="openxr" deprecatedby=""> + <require> + <enum value="1" name="XR_MSFT_composition_layer_reprojection_SPEC_VERSION"/> + <enum value=""XR_MSFT_composition_layer_reprojection"" name="XR_MSFT_COMPOSITION_LAYER_REPROJECTION_EXTENSION_NAME"/> + + <type name="XrReprojectionModeMSFT"/> + <type name="XrCompositionLayerReprojectionInfoMSFT"/> + <type name="XrCompositionLayerReprojectionPlaneOverrideMSFT"/> + + <command name="xrEnumerateReprojectionModesMSFT"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_REPROJECTION_INFO_MSFT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_REPROJECTION_PLANE_OVERRIDE_MSFT"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_REPROJECTION_MODE_UNSUPPORTED_MSFT" comment="The reprojection mode is not supported."/> + + </require> + </extension> + + <extension name="XR_LUNARG_extension_68" number="68" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LUNARG_extension_68_SPEC_VERSION"/> + <enum value=""XR_LUNARG_extension_68"" name="XR_LUNARG_extension_68_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LUNARG_extension_69" number="69" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LUNARG_extension_69_SPEC_VERSION"/> + <enum value=""XR_LUNARG_extension_69"" name="XR_LUNARG_extension_69_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HUAWEI_controller_interaction" number="70" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_HUAWEI_controller_interaction_SPEC_VERSION"/> + <enum value=""XR_HUAWEI_controller_interaction"" name="XR_HUAWEI_CONTROLLER_INTERACTION_EXTENSION_NAME"/> + + <interaction_profile name="/interaction_profiles/huawei/controller"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/huawei/controller"> + <component subpath="/input/trackpad/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_center" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/huawei/controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/huawei/controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_FB_android_surface_swapchain_create" number="71" type="instance" supported="openxr" protect="XR_USE_PLATFORM_ANDROID" depends="XR_VERSION_1_0+XR_KHR_android_surface_swapchain"> + <require> + <enum value="1" name="XR_FB_android_surface_swapchain_create_SPEC_VERSION"/> + <enum value=""XR_FB_android_surface_swapchain_create"" name="XR_FB_ANDROID_SURFACE_SWAPCHAIN_CREATE_EXTENSION_NAME"/> + + <type name="XrAndroidSurfaceSwapchainCreateInfoFB"/> + <type name="XrAndroidSurfaceSwapchainFlagsFB"/> + <type name="XrAndroidSurfaceSwapchainFlagBitsFB"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_ANDROID_SURFACE_SWAPCHAIN_CREATE_INFO_FB"/> + </require> + </extension> + + <extension name="XR_FB_swapchain_update_state" number="72" type="instance" supported="openxr"> + <require> + <enum value="3" name="XR_FB_swapchain_update_state_SPEC_VERSION"/> + <enum value=""XR_FB_swapchain_update_state"" name="XR_FB_SWAPCHAIN_UPDATE_STATE_EXTENSION_NAME"/> + + <type name="XrSwapchainStateBaseHeaderFB"/> + <command name="xrUpdateSwapchainFB"/> + <command name="xrGetSwapchainStateFB"/> + </require> + </extension> + + <extension name="XR_FB_composition_layer_secure_content" number="73" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_composition_layer_secure_content_SPEC_VERSION"/> + <enum value=""XR_FB_composition_layer_secure_content"" name="XR_FB_COMPOSITION_LAYER_SECURE_CONTENT_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_SECURE_CONTENT_FB"/> + <type name="XrCompositionLayerSecureContentFB"/> + </require> + </extension> + + <extension name="XR_FB_extension_74" number="74" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_74_SPEC_VERSION"/> + <enum value=""XR_FB_extension_74"" name="XR_FB_extension_74_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_75" number="75" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_75_SPEC_VERSION"/> + <enum value=""XR_FB_extension_75"" name="XR_FB_extension_75_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_76" number="76" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_76_SPEC_VERSION"/> + <enum value=""XR_FB_extension_76"" name="XR_FB_extension_76_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_body_tracking" number="77" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_body_tracking_SPEC_VERSION"/> + <enum value=""XR_FB_body_tracking"" name="XR_FB_BODY_TRACKING_EXTENSION_NAME"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_BODY_TRACKER_FB" comment="XrBodyTrackerFB"/> + <type name="XrBodyTrackerFB"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_BODY_TRACKER_CREATE_INFO_FB"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_BODY_JOINTS_LOCATE_INFO_FB"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_FB"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_BODY_JOINT_LOCATIONS_FB"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_BODY_SKELETON_FB"/> + + <type name="XrBodyJointFB"/> + <type name="XrBodyJointSetFB"/> + <type name="XrBodyJointFB"/> + <type name="XrBodyJointLocationFB"/> + + <type name="XrSystemBodyTrackingPropertiesFB"/> + <type name="XrBodyTrackerCreateInfoFB"/> + <type name="XrBodySkeletonJointFB"/> + <type name="XrBodySkeletonFB"/> + <type name="XrBodyJointsLocateInfoFB"/> + <type name="XrBodyJointLocationsFB"/> + + <command name="xrCreateBodyTrackerFB"/> + <command name="xrDestroyBodyTrackerFB"/> + <command name="xrLocateBodyJointsFB"/> + <command name="xrGetBodySkeletonFB"/> + </require> + </extension> + + <extension name="XR_FB_extension_78" number="78" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_78_SPEC_VERSION"/> + <enum value=""XR_FB_extension_78"" name="XR_FB_extension_78_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_dpad_binding" number="79" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_KHR_binding_modification" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_dpad_binding_SPEC_VERSION"/> + <enum value=""XR_EXT_dpad_binding"" name="XR_EXT_DPAD_BINDING_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_INTERACTION_PROFILE_DPAD_BINDING_EXT"/> + <type name="XrInteractionProfileDpadBindingEXT"/> + + <!-- + Only core 1.0 interaction profiles get extended here. + Others get this pose added in a nested <require depends="XR_EXT_dpad_binding"> + inside the extension and/or feature that adds them. + --> + <extend interaction_profile_path="/interaction_profiles/google/daydream_controller"> + <component subpath="/input/trackpad/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_center" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/htc/vive_controller"> + <component subpath="/input/trackpad/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_center" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/oculus/go_controller"> + <component subpath="/input/trackpad/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_center" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/oculus/touch_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/microsoft/motion_controller"> + <component subpath="/input/trackpad/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_center" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/microsoft/xbox_controller"> + <component subpath="/input/thumbstick_left/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick_left/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick_left/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick_left/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick_right/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick_right/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick_right/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick_right/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/valve/index_controller"> + <component subpath="/input/trackpad/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_center" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_VALVE_analog_threshold" number="80" type="instance" supported="openxr"> + <require> + <enum value="2" name="XR_VALVE_analog_threshold_SPEC_VERSION"/> + <enum value=""XR_VALVE_analog_threshold"" name="XR_VALVE_ANALOG_THRESHOLD_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_INTERACTION_PROFILE_ANALOG_THRESHOLD_VALVE"/> + <type name="XrInteractionProfileAnalogThresholdVALVE"/> + </require> + </extension> + + <extension name="XR_EXT_hand_joints_motion_range" number="81" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_EXT_hand_tracking" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_hand_joints_motion_range_SPEC_VERSION"/> + <enum value=""XR_EXT_hand_joints_motion_range"" name="XR_EXT_HAND_JOINTS_MOTION_RANGE_EXTENSION_NAME"/> + + <type name="XrHandJointsMotionRangeEXT"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_HAND_JOINTS_MOTION_RANGE_INFO_EXT"/> + <type name="XrHandJointsMotionRangeInfoEXT"/> + </require> + </extension> + + <extension name="XR_VALVE_extension_82" number="82" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VALVE_extension_82_SPEC_VERSION"/> + <enum value=""XR_VALVE_extension_82"" name="XR_VALVE_extension_82_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VALVE_extension_83" number="83" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VALVE_extension_83_SPEC_VERSION"/> + <enum value=""XR_VALVE_extension_83"" name="XR_VALVE_extension_83_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VALVE_extension_84" number="84" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VALVE_extension_84_SPEC_VERSION"/> + <enum value=""XR_VALVE_extension_84"" name="XR_VALVE_extension_84_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VALVE_extension_85" number="85" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VALVE_extension_85_SPEC_VERSION"/> + <enum value=""XR_VALVE_extension_85"" name="XR_VALVE_extension_85_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VALVE_extension_86" number="86" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VALVE_extension_86_SPEC_VERSION"/> + <enum value=""XR_VALVE_extension_86"" name="XR_VALVE_extension_86_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VALVE_extension_87" number="87" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VALVE_extension_87_SPEC_VERSION"/> + <enum value=""XR_VALVE_extension_87"" name="XR_VALVE_extension_87_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VALVE_extension_88" number="88" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VALVE_extension_88_SPEC_VERSION"/> + <enum value=""XR_VALVE_extension_88"" name="XR_VALVE_extension_88_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_KHR_loader_init" number="89" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="2" name="XR_KHR_loader_init_SPEC_VERSION"/> + <enum value=""XR_KHR_loader_init"" name="XR_KHR_LOADER_INIT_EXTENSION_NAME"/> + <type name="XrLoaderInitInfoBaseHeaderKHR"/> + <command name="xrInitializeLoaderKHR"/> + </require> + </extension> + + <extension name="XR_KHR_loader_init_android" number="90" type="instance" supported="openxr" protect="XR_USE_PLATFORM_ANDROID" depends="XR_VERSION_1_0+XR_KHR_loader_init" ratified="openxr"> + <require> + <enum value="1" name="XR_KHR_loader_init_android_SPEC_VERSION"/> + <enum value=""XR_KHR_loader_init_android"" name="XR_KHR_LOADER_INIT_ANDROID_EXTENSION_NAME"/> + <type name="XrLoaderInitInfoAndroidKHR"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_LOADER_INIT_INFO_ANDROID_KHR"/> + </require> + </extension> + + <extension name="XR_KHR_vulkan_enable2" number="91" type="instance" protect="XR_USE_GRAPHICS_API_VULKAN" supported="openxr" ratified="openxr"> + <require> + <enum value="4" name="XR_KHR_vulkan_enable2_SPEC_VERSION"/> + <enum value=""XR_KHR_vulkan_enable2"" name="XR_KHR_VULKAN_ENABLE2_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_VULKAN_INSTANCE_CREATE_INFO_KHR"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_VULKAN_DEVICE_CREATE_INFO_KHR"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_VULKAN_GRAPHICS_DEVICE_GET_INFO_KHR"/> + <enum extends="XrStructureType" name="XR_TYPE_GRAPHICS_BINDING_VULKAN2_KHR" alias="XR_TYPE_GRAPHICS_BINDING_VULKAN_KHR"/> + <enum extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_IMAGE_VULKAN2_KHR" alias="XR_TYPE_SWAPCHAIN_IMAGE_VULKAN_KHR"/> + <enum extends="XrStructureType" name="XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN2_KHR" alias="XR_TYPE_GRAPHICS_REQUIREMENTS_VULKAN_KHR"/> + <type name="XrVulkanInstanceCreateInfoKHR"/> + <type name="XrVulkanDeviceCreateInfoKHR"/> + <type name="XrGraphicsBindingVulkan2KHR"/> + <type name="XrVulkanInstanceCreateFlagsKHR"/> + <type name="XrVulkanInstanceCreateFlagBitsKHR"/> + <type name="XrVulkanDeviceCreateFlagsKHR"/> + <type name="XrVulkanDeviceCreateFlagBitsKHR"/> + <type name="XrVulkanGraphicsDeviceGetInfoKHR"/> + <type name="XrSwapchainImageVulkan2KHR"/> + <type name="XrGraphicsRequirementsVulkan2KHR"/> + <command name="xrCreateVulkanInstanceKHR"/> + <command name="xrCreateVulkanDeviceKHR"/> + <command name="xrGetVulkanGraphicsDevice2KHR"/> + <command name="xrGetVulkanGraphicsRequirements2KHR"/> + </require> + </extension> + + <extension name="XR_KHR_composition_layer_equirect2" number="92" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="1" name="XR_KHR_composition_layer_equirect2_SPEC_VERSION"/> + <enum value=""XR_KHR_composition_layer_equirect2"" name="XR_KHR_COMPOSITION_LAYER_EQUIRECT2_EXTENSION_NAME"/> + <type name="XrCompositionLayerEquirect2KHR"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_EQUIRECT2_KHR"/> + </require> + </extension> + + <extension name="XR_EXT_extension_93" number="93" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_93_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_93"" name="XR_EXT_extension_93_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_system_extensions" number="94" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_system_extensions_SPEC_VERSION"/> + <enum value=""XR_EXT_system_extensions"" name="XR_EXT_system_extensions_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_samsung_odyssey_controller" number="95" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="1" name="XR_EXT_samsung_odyssey_controller_SPEC_VERSION"/> + <enum value=""XR_EXT_samsung_odyssey_controller"" name="XR_EXT_SAMSUNG_ODYSSEY_CONTROLLER_EXTENSION_NAME"/> + + <interaction_profile name="/interaction_profiles/samsung/odyssey_controller"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/samsung/odyssey_controller"> + <component subpath="/input/trackpad/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_center" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/samsung/odyssey_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/samsung/odyssey_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_EXT_hp_mixed_reality_controller" number="96" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="1" name="XR_EXT_hp_mixed_reality_controller_SPEC_VERSION"/> + <enum value=""XR_EXT_hp_mixed_reality_controller"" name="XR_EXT_HP_MIXED_REALITY_CONTROLLER_EXTENSION_NAME"/> + + <interaction_profile name="/interaction_profiles/hp/mixed_reality_controller"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/hp/mixed_reality_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/hp/mixed_reality_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/hp/mixed_reality_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_MND_swapchain_usage_input_attachment_bit" number="97" type="instance" supported="openxr" deprecatedby="XR_KHR_swapchain_usage_input_attachment_bit"> + <require> + <enum value="2" name="XR_MND_swapchain_usage_input_attachment_bit_SPEC_VERSION"/> + <enum value=""XR_MND_swapchain_usage_input_attachment_bit"" name="XR_MND_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_EXTENSION_NAME"/> + <!-- NOTE: This was added before the working group established a process, and has been normalized by promotion to KHR. Future vendor extensions MUST NOT extend core bitmasks. --> + <enum bitpos="7" extends="XrSwapchainUsageFlagBits" name="XR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_MND" comment="Specifies that the image may: be used as a input attachment."/> + </require> + </extension> + + <extension name="XR_MSFT_scene_understanding" number="98" type="instance" supported="openxr" obsoletedby="XR_EXT_spatial_entity"> + <require> + <enum value="2" name="XR_MSFT_scene_understanding_SPEC_VERSION"/> + <enum value=""XR_MSFT_scene_understanding"" name="XR_MSFT_SCENE_UNDERSTANDING_EXTENSION_NAME"/> + <type name="XrUuidMSFT"/> + <type name="XrSceneMSFT"/> + <type name="XrSceneObserverMSFT"/> + <type name="XrSceneObserverCreateInfoMSFT"/> + <type name="XrSceneCreateInfoMSFT"/> + <type name="XrNewSceneComputeInfoMSFT"/> + <type name="XrVisualMeshComputeLodInfoMSFT"/> + <type name="XrSceneSphereBoundMSFT"/> + <type name="XrSceneOrientedBoxBoundMSFT"/> + <type name="XrSceneFrustumBoundMSFT"/> + <type name="XrSceneBoundsMSFT"/> + <type name="XrSceneComponentMSFT"/> + <type name="XrSceneComponentsMSFT"/> + <type name="XrSceneComponentsGetInfoMSFT"/> + <type name="XrSceneComponentLocationMSFT"/> + <type name="XrSceneComponentLocationsMSFT"/> + <type name="XrSceneComponentsLocateInfoMSFT"/> + <type name="XrSceneObjectMSFT"/> + <type name="XrSceneObjectsMSFT"/> + <type name="XrSceneComponentParentFilterInfoMSFT"/> + <type name="XrSceneObjectTypesFilterInfoMSFT"/> + <type name="XrScenePlaneMSFT"/> + <type name="XrScenePlanesMSFT"/> + <type name="XrScenePlaneAlignmentFilterInfoMSFT"/> + <type name="XrSceneMeshMSFT"/> + <type name="XrSceneMeshesMSFT"/> + <type name="XrSceneMeshBuffersGetInfoMSFT"/> + <type name="XrSceneMeshBuffersMSFT"/> + <type name="XrSceneMeshVertexBufferMSFT"/> + <type name="XrSceneMeshIndicesUint32MSFT"/> + <type name="XrSceneMeshIndicesUint16MSFT"/> + <type name="XrSceneObjectTypeMSFT"/> + <type name="XrScenePlaneAlignmentTypeMSFT"/> + <type name="XrSceneComputeStateMSFT"/> + <type name="XrSceneComponentTypeMSFT"/> + <type name="XrSceneComputeFeatureMSFT"/> + <type name="XrSceneComputeConsistencyMSFT"/> + <type name="XrMeshComputeLodMSFT"/> + <command name="xrEnumerateSceneComputeFeaturesMSFT"/> + <command name="xrCreateSceneObserverMSFT"/> + <command name="xrDestroySceneObserverMSFT"/> + <command name="xrCreateSceneMSFT"/> + <command name="xrDestroySceneMSFT"/> + <command name="xrComputeNewSceneMSFT"/> + <command name="xrGetSceneComputeStateMSFT"/> + <command name="xrGetSceneComponentsMSFT"/> + <command name="xrLocateSceneComponentsMSFT"/> + <command name="xrGetSceneMeshBuffersMSFT"/> + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SCENE_OBSERVER_MSFT" comment="XrSceneObserverMSFT"/> + <enum offset="1" extends="XrObjectType" name="XR_OBJECT_TYPE_SCENE_MSFT" comment="XrSceneMSFT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SCENE_OBSERVER_CREATE_INFO_MSFT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SCENE_CREATE_INFO_MSFT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_NEW_SCENE_COMPUTE_INFO_MSFT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_VISUAL_MESH_COMPUTE_LOD_INFO_MSFT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SCENE_COMPONENTS_MSFT"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_SCENE_COMPONENTS_GET_INFO_MSFT"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_SCENE_COMPONENT_LOCATIONS_MSFT"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_SCENE_COMPONENTS_LOCATE_INFO_MSFT"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_SCENE_OBJECTS_MSFT"/> + <enum offset="9" extends="XrStructureType" name="XR_TYPE_SCENE_COMPONENT_PARENT_FILTER_INFO_MSFT"/> + <enum offset="10" extends="XrStructureType" name="XR_TYPE_SCENE_OBJECT_TYPES_FILTER_INFO_MSFT"/> + <enum offset="11" extends="XrStructureType" name="XR_TYPE_SCENE_PLANES_MSFT"/> + <enum offset="12" extends="XrStructureType" name="XR_TYPE_SCENE_PLANE_ALIGNMENT_FILTER_INFO_MSFT"/> + <enum offset="13" extends="XrStructureType" name="XR_TYPE_SCENE_MESHES_MSFT"/> + <enum offset="14" extends="XrStructureType" name="XR_TYPE_SCENE_MESH_BUFFERS_GET_INFO_MSFT"/> + <enum offset="15" extends="XrStructureType" name="XR_TYPE_SCENE_MESH_BUFFERS_MSFT"/> + <enum offset="16" extends="XrStructureType" name="XR_TYPE_SCENE_MESH_VERTEX_BUFFER_MSFT"/> + <enum offset="17" extends="XrStructureType" name="XR_TYPE_SCENE_MESH_INDICES_UINT32_MSFT"/> + <enum offset="18" extends="XrStructureType" name="XR_TYPE_SCENE_MESH_INDICES_UINT16_MSFT"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_COMPUTE_NEW_SCENE_NOT_COMPLETED_MSFT" comment="Compute new scene not completed."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SCENE_COMPONENT_ID_INVALID_MSFT" comment="Scene component id invalid."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_SCENE_COMPONENT_TYPE_MISMATCH_MSFT" comment="Scene component type mismatch."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_SCENE_MESH_BUFFER_ID_INVALID_MSFT" comment="Scene mesh buffer id invalid."/> + <enum offset="4" dir="-" extends="XrResult" name="XR_ERROR_SCENE_COMPUTE_FEATURE_INCOMPATIBLE_MSFT" comment="Scene compute feature incompatible."/> + <enum offset="5" dir="-" extends="XrResult" name="XR_ERROR_SCENE_COMPUTE_CONSISTENCY_MISMATCH_MSFT" comment="Scene compute consistency mismatch."/> + </require> + </extension> + + <extension name="XR_MSFT_scene_understanding_serialization" number="99" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_MSFT_scene_understanding" deprecatedby=""> + <require> + <enum value="2" name="XR_MSFT_scene_understanding_serialization_SPEC_VERSION"/> + <enum value=""XR_MSFT_scene_understanding_serialization"" name="XR_MSFT_SCENE_UNDERSTANDING_SERIALIZATION_EXTENSION_NAME"/> + <type name="XrSerializedSceneFragmentDataGetInfoMSFT"/> + <type name="XrDeserializeSceneFragmentMSFT"/> + <type name="XrSceneDeserializeInfoMSFT"/> + <command name="xrDeserializeSceneMSFT"/> + <command name="xrGetSerializedSceneFragmentDataMSFT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SERIALIZED_SCENE_FRAGMENT_DATA_GET_INFO_MSFT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SCENE_DESERIALIZE_INFO_MSFT"/> + <enum offset="0" extends="XrSceneComputeFeatureMSFT" name="XR_SCENE_COMPUTE_FEATURE_SERIALIZE_SCENE_MSFT"/> + <enum offset="0" extends="XrSceneComponentTypeMSFT" name="XR_SCENE_COMPONENT_TYPE_SERIALIZED_SCENE_FRAGMENT_MSFT"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_100" number="100" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_100_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_100"" name="XR_MSFT_extension_100_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_101" number="101" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_101_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_101"" name="XR_MSFT_extension_101_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_display_refresh_rate" number="102" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_display_refresh_rate_SPEC_VERSION"/> + <enum value=""XR_FB_display_refresh_rate"" name="XR_FB_DISPLAY_REFRESH_RATE_EXTENSION_NAME"/> + + <type name="XrEventDataDisplayRefreshRateChangedFB"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB"/> + + <command name="xrEnumerateDisplayRefreshRatesFB"/> + <command name="xrGetDisplayRefreshRateFB"/> + <command name="xrRequestDisplayRefreshRateFB"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_DISPLAY_REFRESH_RATE_UNSUPPORTED_FB" comment="The display refresh rate is not supported by the platform."/> + </require> + </extension> + + <extension name="XR_HTC_vive_cosmos_controller_interaction" number="103" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="1" name="XR_HTC_vive_cosmos_controller_interaction_SPEC_VERSION"/> + <enum value=""XR_HTC_vive_cosmos_controller_interaction"" name="XR_HTC_VIVE_COSMOS_CONTROLLER_INTERACTION_EXTENSION_NAME"/> + + <interaction_profile name="/interaction_profiles/htc/vive_cosmos_controller"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_cosmos_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_cosmos_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_cosmos_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_HTCX_vive_tracker_interaction" number="104" type="instance" provisional="true" supported="openxr"> + <require> + <enum value="3" name="XR_HTCX_vive_tracker_interaction_SPEC_VERSION"/> + <enum value=""XR_HTCX_vive_tracker_interaction"" name="XR_HTCX_VIVE_TRACKER_INTERACTION_EXTENSION_NAME"/> + <type name="XrViveTrackerPathsHTCX"/> + <type name="XrEventDataViveTrackerConnectedHTCX"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_VIVE_TRACKER_PATHS_HTCX"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_VIVE_TRACKER_CONNECTED_HTCX"/> + <command name="xrEnumerateViveTrackerPathsHTCX"/> + <interaction_profile name="/interaction_profiles/htc/vive_tracker_htcx"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_tracker_htcx"> + <component subpath="/input/trackpad/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_center" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_HTC_facial_tracking" number="105" type="instance" supported="openxr"> + <require> + <enum value="3" name="XR_HTC_facial_tracking_SPEC_VERSION"/> + <enum value=""XR_HTC_facial_tracking"" name="XR_HTC_FACIAL_TRACKING_EXTENSION_NAME"/> + + <type name="XrFacialTrackerHTC"/> + <type name="XrSystemFacialTrackingPropertiesHTC"/> + <type name="XrFacialExpressionsHTC"/> + <type name="XrEyeExpressionHTC"/> + <type name="XrLipExpressionHTC"/> + <type name="XrFacialTrackerCreateInfoHTC"/> + <type name="XrFacialTrackingTypeHTC"/> + <type name="XR_FACIAL_EXPRESSION_EYE_COUNT_HTC"/> + <type name="XR_FACIAL_EXPRESSION_LIP_COUNT_HTC"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_FACIAL_TRACKER_HTC" comment="XrFacialTrackerHTC"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_FACIAL_TRACKING_PROPERTIES_HTC"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_FACIAL_TRACKER_CREATE_INFO_HTC"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_FACIAL_EXPRESSIONS_HTC"/> + + <command name="xrCreateFacialTrackerHTC"/> + <command name="xrDestroyFacialTrackerHTC"/> + <command name="xrGetFacialExpressionsHTC"/> + + <enum extends="XrLipExpressionHTC" name="XR_LIP_EXPRESSION_MOUTH_SMILE_RIGHT_HTC" alias="XR_LIP_EXPRESSION_MOUTH_RAISER_RIGHT_HTC" comment="Backward-compatibility alias for deprecated name."/> + <enum extends="XrLipExpressionHTC" name="XR_LIP_EXPRESSION_MOUTH_SMILE_LEFT_HTC" alias="XR_LIP_EXPRESSION_MOUTH_RAISER_LEFT_HTC" comment="Backward-compatibility alias for deprecated name."/> + <enum extends="XrLipExpressionHTC" name="XR_LIP_EXPRESSION_MOUTH_SAD_RIGHT_HTC" alias="XR_LIP_EXPRESSION_MOUTH_STRETCHER_RIGHT_HTC" comment="Backward-compatibility alias for deprecated name."/> + <enum extends="XrLipExpressionHTC" name="XR_LIP_EXPRESSION_MOUTH_SAD_LEFT_HTC" alias="XR_LIP_EXPRESSION_MOUTH_STRETCHER_LEFT_HTC" comment="Backward-compatibility alias for deprecated name."/> + </require> + </extension> + + <extension name="XR_HTC_vive_focus3_controller_interaction" number="106" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="2" name="XR_HTC_vive_focus3_controller_interaction_SPEC_VERSION"/> + <enum value=""XR_HTC_vive_focus3_controller_interaction"" name="XR_HTC_VIVE_FOCUS3_CONTROLLER_INTERACTION_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/htc/vive_focus3_controller"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_focus3_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_focus3_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_focus3_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_HTC_hand_interaction" number="107" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_HTC_hand_interaction_SPEC_VERSION"/> + <enum value=""XR_HTC_hand_interaction"" name="XR_HTC_HAND_INTERACTION_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/htc/hand_interaction"/> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/htc/hand_interaction"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/htc/hand_interaction"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_HTC_vive_wrist_tracker_interaction" number="108" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_HTC_vive_wrist_tracker_interaction_SPEC_VERSION"/> + <enum value=""XR_HTC_vive_wrist_tracker_interaction"" name="XR_HTC_VIVE_WRIST_TRACKER_INTERACTION_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/htc/vive_wrist_tracker"/> + </require> + </extension> + + <extension name="XR_FB_color_space" number="109" type="instance" supported="openxr"> + <require> + <enum value="3" name="XR_FB_color_space_SPEC_VERSION"/> + <enum value=""XR_FB_color_space"" name="XR_FB_COLOR_SPACE_EXTENSION_NAME"/> + + <type name="XrColorSpaceFB"/> + <type name="XrSystemColorSpacePropertiesFB"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_COLOR_SPACE_PROPERTIES_FB"/> + + <command name="xrEnumerateColorSpacesFB"/> + <command name="xrSetColorSpaceFB"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_COLOR_SPACE_UNSUPPORTED_FB" comment="The color space is not supported by the runtime."/> + </require> + </extension> + + <extension name="XR_FB_extension_110" number="110" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_110_SPEC_VERSION"/> + <enum value=""XR_FB_extension_110"" name="XR_FB_extension_110_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_hand_tracking_mesh" number="111" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_EXT_hand_tracking"> + <require> + <enum value="3" name="XR_FB_hand_tracking_mesh_SPEC_VERSION"/> + <enum value=""XR_FB_hand_tracking_mesh"" name="XR_FB_HAND_TRACKING_MESH_EXTENSION_NAME"/> + + <type name="XrVector4sFB"/> + <type name="XrHandTrackingMeshFB"/> + <type name="XrHandTrackingScaleFB"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_HAND_TRACKING_MESH_FB"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_HAND_TRACKING_SCALE_FB"/> + + <command name="xrGetHandMeshFB"/> + </require> + </extension> + + <extension name="XR_FB_hand_tracking_aim" number="112" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_EXT_hand_tracking"> + <require> + <enum value="2" name="XR_FB_hand_tracking_aim_SPEC_VERSION"/> + <enum value=""XR_FB_hand_tracking_aim"" name="XR_FB_HAND_TRACKING_AIM_EXTENSION_NAME"/> + + <type name="XrHandTrackingAimStateFB"/> + <type name="XrHandTrackingAimFlagsFB"/> + <type name="XrHandTrackingAimFlagBitsFB"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_HAND_TRACKING_AIM_STATE_FB"/> + </require> + </extension> + + <extension name="XR_FB_hand_tracking_capsules" number="113" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_EXT_hand_tracking"> + <require> + <enum value="3" name="XR_FB_hand_tracking_capsules_SPEC_VERSION"/> + <enum value=""XR_FB_hand_tracking_capsules"" name="XR_FB_HAND_TRACKING_CAPSULES_EXTENSION_NAME"/> + + <type name="XrHandCapsuleFB"/> + <type name="XrHandTrackingCapsulesStateFB"/> + + <enum value="2" name="XR_HAND_TRACKING_CAPSULE_POINT_COUNT_FB"/> + <enum value="19" name="XR_HAND_TRACKING_CAPSULE_COUNT_FB"/> + + <enum name="XR_FB_HAND_TRACKING_CAPSULE_POINT_COUNT" alias="XR_HAND_TRACKING_CAPSULE_POINT_COUNT_FB" comment="Backward-compatibility alias containing typo."/> + + <enum name="XR_FB_HAND_TRACKING_CAPSULE_COUNT" alias="XR_HAND_TRACKING_CAPSULE_COUNT_FB" comment="Backward-compatibility alias containing typo."/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_HAND_TRACKING_CAPSULES_STATE_FB"/> + </require> + </extension> + + <extension name="XR_FB_spatial_entity" number="114" type="instance" supported="openxr"> + <require> + <enum value="3" name="XR_FB_spatial_entity_SPEC_VERSION"/> + <enum value=""XR_FB_spatial_entity"" name="XR_FB_SPATIAL_ENTITY_EXTENSION_NAME"/> + + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPATIAL_ENTITY_PROPERTIES_FB"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_FB"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_SPACE_COMPONENT_STATUS_SET_INFO_FB"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPACE_COMPONENT_STATUS_FB"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPATIAL_ANCHOR_CREATE_COMPLETE_FB"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPACE_SET_STATUS_COMPLETE_FB"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SPACE_COMPONENT_NOT_SUPPORTED_FB" comment="The component type is not supported for this space."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPACE_COMPONENT_NOT_ENABLED_FB" comment="The required component is not enabled for this space."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_SPACE_COMPONENT_STATUS_PENDING_FB" comment="A request to set the component's status is currently pending."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_SPACE_COMPONENT_STATUS_ALREADY_SET_FB" comment="The component is already set to the requested value."/> + + <type name="XrAsyncRequestIdFB"/> + + <type name="XrSpaceComponentTypeFB"/> + + <type name="XrSystemSpatialEntityPropertiesFB"/> + <type name="XrSpatialAnchorCreateInfoFB"/> + <type name="XrSpaceComponentStatusSetInfoFB"/> + <type name="XrSpaceComponentStatusFB"/> + + <type name="XrEventDataSpatialAnchorCreateCompleteFB"/> + <type name="XrEventDataSpaceSetStatusCompleteFB"/> + + <command name="xrCreateSpatialAnchorFB"/> + <command name="xrGetSpaceUuidFB"/> + <command name="xrEnumerateSpaceSupportedComponentsFB"/> + <command name="xrSetSpaceComponentStatusFB"/> + <command name="xrGetSpaceComponentStatusFB"/> + </require> + </extension> + + <extension name="XR_FB_foveation" number="115" type="instance" depends="XR_VERSION_1_0+XR_FB_swapchain_update_state" supported="openxr"> + <require> + <enum value="1" name="XR_FB_foveation_SPEC_VERSION"/> + <enum value=""XR_FB_foveation"" name="XR_FB_FOVEATION_EXTENSION_NAME"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_FOVEATION_PROFILE_FB" comment="XrFoveationProfileFB"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_FOVEATION_PROFILE_CREATE_INFO_FB"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_CREATE_INFO_FOVEATION_FB"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_STATE_FOVEATION_FB"/> + + <type name="XrFoveationProfileFB"/> + <type name="XrFoveationProfileCreateInfoFB"/> + <type name="XrSwapchainCreateInfoFoveationFB"/> + <type name="XrSwapchainCreateFoveationFlagsFB"/> + <type name="XrSwapchainCreateFoveationFlagBitsFB"/> + <type name="XrSwapchainStateFoveationFB"/> + <type name="XrSwapchainStateFoveationFlagsFB"/> + <type name="XrSwapchainStateFoveationFlagBitsFB"/> + + <command name="xrCreateFoveationProfileFB"/> + <command name="xrDestroyFoveationProfileFB"/> + </require> + </extension> + + <extension name="XR_FB_foveation_configuration" number="116" type="instance" depends="XR_VERSION_1_0+XR_FB_foveation" supported="openxr"> + <require> + <enum value="1" name="XR_FB_foveation_configuration_SPEC_VERSION"/> + <enum value=""XR_FB_foveation_configuration"" name="XR_FB_FOVEATION_CONFIGURATION_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_FOVEATION_LEVEL_PROFILE_CREATE_INFO_FB"/> + + <type name="XrFoveationLevelFB"/> + <type name="XrFoveationDynamicFB"/> + <type name="XrFoveationLevelProfileCreateInfoFB"/> + </require> + </extension> + + <extension name="XR_FB_keyboard_tracking" number="117" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_keyboard_tracking_SPEC_VERSION"/> + <enum value=""XR_FB_keyboard_tracking"" name="XR_FB_KEYBOARD_TRACKING_EXTENSION_NAME"/> + + <type name="XrSystemKeyboardTrackingPropertiesFB"/> + <type name="XrKeyboardTrackingDescriptionFB"/> + <type name="XrKeyboardSpaceCreateInfoFB"/> + <type name="XrKeyboardTrackingQueryFB"/> + <type name="XrKeyboardTrackingQueryFlagsFB"/> + <type name="XrKeyboardTrackingQueryFlagBitsFB"/> + <type name="XrKeyboardTrackingFlagsFB"/> + <type name="XrKeyboardTrackingFlagBitsFB"/> + + <enum value="128" name="XR_MAX_KEYBOARD_TRACKING_NAME_SIZE_FB"/> + + <enum offset="9" extends="XrStructureType" name="XR_TYPE_KEYBOARD_SPACE_CREATE_INFO_FB"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_KEYBOARD_TRACKING_QUERY_FB"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SYSTEM_KEYBOARD_TRACKING_PROPERTIES_FB"/> + + <command name="xrQuerySystemTrackedKeyboardFB"/> + <command name="xrCreateKeyboardSpaceFB"/> + </require> + </extension> + + <extension name="XR_FB_triangle_mesh" number="118" type="instance" supported="openxr"> + <require> + <enum value="2" name="XR_FB_triangle_mesh_SPEC_VERSION"/> + <enum value=""XR_FB_triangle_mesh"" name="XR_FB_TRIANGLE_MESH_EXTENSION_NAME"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_TRIANGLE_MESH_CREATE_INFO_FB"/> + + <type name="XrTriangleMeshFB"/> + <type name="XrTriangleMeshFlagsFB"/> + <type name="XrTriangleMeshFlagBitsFB"/> + <type name="XrTriangleMeshCreateInfoFB"/> + <type name="XrWindingOrderFB"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_TRIANGLE_MESH_FB" comment="XrTriangleMeshFB"/> + + <command name="xrCreateTriangleMeshFB"/> + <command name="xrDestroyTriangleMeshFB"/> + <command name="xrTriangleMeshGetVertexBufferFB"/> + <command name="xrTriangleMeshGetIndexBufferFB"/> + <command name="xrTriangleMeshBeginUpdateFB"/> + <command name="xrTriangleMeshEndUpdateFB"/> + <command name="xrTriangleMeshBeginVertexBufferUpdateFB"/> + <command name="xrTriangleMeshEndVertexBufferUpdateFB"/> + </require> + </extension> + + <extension name="XR_FB_passthrough" number="119" type="instance" supported="openxr"> + <require> + <enum value="5" name="XR_FB_passthrough_SPEC_VERSION"/> + <enum value=""XR_FB_passthrough"" name="XR_FB_PASSTHROUGH_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_PASSTHROUGH_PROPERTIES_FB"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_CREATE_INFO_FB"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_FB"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_FB"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_GEOMETRY_INSTANCE_CREATE_INFO_FB"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_GEOMETRY_INSTANCE_TRANSFORM_FB"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_SYSTEM_PASSTHROUGH_PROPERTIES2_FB"/> + <enum offset="20" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_STYLE_FB"/> + <enum offset="21" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_RGBA_FB"/> + <enum offset="22" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_COLOR_MAP_MONO_TO_MONO_FB"/> + <enum offset="23" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_BRIGHTNESS_CONTRAST_SATURATION_FB"/> + <enum offset="30" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_PASSTHROUGH_STATE_CHANGED_FB"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_UNEXPECTED_STATE_PASSTHROUGH_FB" comment="The object state is unexpected for the issued command."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_FEATURE_ALREADY_CREATED_PASSTHROUGH_FB" comment="Trying to create an MR feature when one was already created and only one instance is allowed."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_FEATURE_REQUIRED_PASSTHROUGH_FB" comment="Requested functionality requires a feature to be created first."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_NOT_PERMITTED_PASSTHROUGH_FB" comment="Requested functionality is not permitted - application is not allowed to perform the requested operation."/> + <enum offset="4" dir="-" extends="XrResult" name="XR_ERROR_INSUFFICIENT_RESOURCES_PASSTHROUGH_FB" comment="There were insufficient resources available to perform an operation."/> + <enum offset="50" dir="-" extends="XrResult" name="XR_ERROR_UNKNOWN_PASSTHROUGH_FB" comment="Unknown Passthrough error (no further details provided)."/> + + <enum value="256" name="XR_PASSTHROUGH_COLOR_MAP_MONO_SIZE_FB"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_PASSTHROUGH_FB" comment="XrPassthroughFB"/> + <enum offset="2" extends="XrObjectType" name="XR_OBJECT_TYPE_PASSTHROUGH_LAYER_FB" comment="XrPassthroughLayerFB"/> + <enum offset="4" extends="XrObjectType" name="XR_OBJECT_TYPE_GEOMETRY_INSTANCE_FB" comment="XrGeometryInstanceFB"/> + + <type name="XrSystemPassthroughPropertiesFB"/> + <type name="XrSystemPassthroughProperties2FB"/> + <type name="XrPassthroughCreateInfoFB"/> + <type name="XrPassthroughLayerCreateInfoFB"/> + <type name="XrCompositionLayerPassthroughFB"/> + <type name="XrGeometryInstanceCreateInfoFB"/> + <type name="XrGeometryInstanceTransformFB"/> + <type name="XrPassthroughStyleFB"/> + <type name="XrPassthroughColorMapMonoToRgbaFB"/> + <type name="XrPassthroughColorMapMonoToMonoFB"/> + <type name="XrPassthroughBrightnessContrastSaturationFB"/> + <type name="XrEventDataPassthroughStateChangedFB"/> + + <type name="XrPassthroughFB"/> + <type name="XrPassthroughFlagsFB"/> + <type name="XrPassthroughFlagBitsFB"/> + <type name="XrPassthroughCapabilityFlagsFB"/> + <type name="XrPassthroughCapabilityFlagBitsFB"/> + <type name="XrGeometryInstanceFB"/> + <type name="XrPassthroughLayerFB"/> + <type name="XrPassthroughLayerPurposeFB"/> + <type name="XrPassthroughStateChangedFlagsFB"/> + <type name="XrPassthroughStateChangedFlagBitsFB"/> + + <command name="xrCreatePassthroughFB"/> + <command name="xrDestroyPassthroughFB"/> + <command name="xrPassthroughStartFB"/> + <command name="xrPassthroughPauseFB"/> + <command name="xrCreatePassthroughLayerFB"/> + <command name="xrDestroyPassthroughLayerFB"/> + <command name="xrPassthroughLayerPauseFB"/> + <command name="xrPassthroughLayerResumeFB"/> + <command name="xrPassthroughLayerSetStyleFB"/> + <command name="xrCreateGeometryInstanceFB"/> + <command name="xrDestroyGeometryInstanceFB"/> + <command name="xrGeometryInstanceSetTransformFB"/> + </require> + </extension> + + <extension name="XR_FB_render_model" number="120" type="instance" supported="openxr"> + <require> + <enum value="4" name="XR_FB_render_model_SPEC_VERSION"/> + <enum value=""XR_FB_render_model"" name="XR_FB_RENDER_MODEL_EXTENSION_NAME"/> + + <type name="XrRenderModelPathInfoFB"/> + <type name="XrRenderModelPropertiesFB"/> + <type name="XrRenderModelBufferFB"/> + <type name="XrRenderModelLoadInfoFB"/> + <type name="XrRenderModelKeyFB"/> + <type name="XrSystemRenderModelPropertiesFB"/> + <type name="XrRenderModelCapabilitiesRequestFB"/> + <type name="XrRenderModelFlagsFB"/> + <type name="XrRenderModelFlagBitsFB"/> + <type name="XR_NULL_RENDER_MODEL_KEY_FB"/> + + <command name="xrEnumerateRenderModelPathsFB"/> + <command name="xrGetRenderModelPropertiesFB"/> + <command name="xrLoadRenderModelFB"/> + + <enum value="64" name="XR_MAX_RENDER_MODEL_NAME_SIZE_FB"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_PATH_INFO_FB"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_PROPERTIES_FB"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_BUFFER_FB"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_LOAD_INFO_FB"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SYSTEM_RENDER_MODEL_PROPERTIES_FB"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_CAPABILITIES_REQUEST_FB"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_RENDER_MODEL_KEY_INVALID_FB" comment="The model key is invalid."/> + <enum offset="20" extends="XrResult" name="XR_RENDER_MODEL_UNAVAILABLE_FB" comment="The model is unavailable."/> + </require> + </extension> + + <extension name="XR_KHR_binding_modification" number="121" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="1" name="XR_KHR_binding_modification_SPEC_VERSION"/> + <enum value=""XR_KHR_binding_modification"" name="XR_KHR_BINDING_MODIFICATION_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_BINDING_MODIFICATIONS_KHR"/> + <type name="XrBindingModificationsKHR"/> + <type name="XrBindingModificationBaseHeaderKHR"/> + </require> + </extension> + + <extension name="XR_VARJO_foveated_rendering" number="122" type="instance" depends="XR_VERSION_1_0+XR_VARJO_quad_views" supported="openxr"> + <require> + <enum value="3" name="XR_VARJO_foveated_rendering_SPEC_VERSION"/> + <enum value=""XR_VARJO_foveated_rendering"" name="XR_VARJO_FOVEATED_RENDERING_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_VIEW_LOCATE_FOVEATED_RENDERING_VARJO"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_FOVEATED_VIEW_CONFIGURATION_VIEW_VARJO"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SYSTEM_FOVEATED_RENDERING_PROPERTIES_VARJO"/> + + <enum offset="0" extends="XrReferenceSpaceType" name="XR_REFERENCE_SPACE_TYPE_COMBINED_EYE_VARJO"/> + + <type name="XrViewLocateFoveatedRenderingVARJO"/> + <type name="XrFoveatedViewConfigurationViewVARJO"/> + <type name="XrSystemFoveatedRenderingPropertiesVARJO"/> + </require> + </extension> + + <extension name="XR_VARJO_composition_layer_depth_test" number="123" type="instance" depends="XR_VERSION_1_0+XR_KHR_composition_layer_depth" supported="openxr"> + <require> + <enum value="2" name="XR_VARJO_composition_layer_depth_test_SPEC_VERSION"/> + <enum value=""XR_VARJO_composition_layer_depth_test"" name="XR_VARJO_COMPOSITION_LAYER_DEPTH_TEST_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_DEPTH_TEST_VARJO"/> + <type name="XrCompositionLayerDepthTestVARJO"/> + </require> + </extension> + + <extension name="XR_VARJO_environment_depth_estimation" number="124" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_VARJO_environment_depth_estimation_SPEC_VERSION"/> + <enum value=""XR_VARJO_environment_depth_estimation"" name="XR_VARJO_ENVIRONMENT_DEPTH_ESTIMATION_EXTENSION_NAME"/> + <command name="xrSetEnvironmentDepthEstimationVARJO"/> + </require> + </extension> + + <extension name="XR_VARJO_marker_tracking" number="125" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_VARJO_marker_tracking_SPEC_VERSION"/> + <enum value=""XR_VARJO_marker_tracking"" name="XR_VARJO_MARKER_TRACKING_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_VARJO"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_MARKER_TRACKING_UPDATE_VARJO"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_MARKER_SPACE_CREATE_INFO_VARJO"/> + + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_MARKER_NOT_TRACKED_VARJO" comment="Marker tracking is disabled or the specified marker is not currently tracked."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_MARKER_ID_INVALID_VARJO" comment="The specified marker ID is not valid."/> + + <type name="XrSystemMarkerTrackingPropertiesVARJO"/> + <type name="XrEventDataMarkerTrackingUpdateVARJO"/> + <type name="XrMarkerSpaceCreateInfoVARJO"/> + + <command name="xrSetMarkerTrackingVARJO"/> + <command name="xrSetMarkerTrackingTimeoutVARJO"/> + <command name="xrSetMarkerTrackingPredictionVARJO"/> + <command name="xrGetMarkerSizeVARJO"/> + <command name="xrCreateMarkerSpaceVARJO"/> + </require> + </extension> + + <extension name="XR_VARJO_view_offset" number="126" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_VARJO_view_offset_SPEC_VERSION"/> + <enum value=""XR_VARJO_view_offset"" name="XR_VARJO_VIEW_OFFSET_EXTENSION_NAME"/> + <command name="xrSetViewOffsetVARJO"/> + </require> + </extension> + + <extension name="XR_VARJO_extension_127" number="127" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VARJO_extension_127_SPEC_VERSION"/> + <enum value=""XR_VARJO_extension_127"" name="XR_VARJO_extension_127_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VARJO_extension_128" number="128" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VARJO_extension_128_SPEC_VERSION"/> + <enum value=""XR_VARJO_extension_128"" name="XR_VARJO_extension_128_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VARJO_extension_129" number="129" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VARJO_extension_129_SPEC_VERSION"/> + <enum value=""XR_VARJO_extension_129"" name="XR_VARJO_extension_129_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VARJO_xr4_controller_interaction" number="130" type="instance" supported="openxr"> + <require> + <enum value="2" name="XR_VARJO_xr4_controller_interaction_SPEC_VERSION"/> + <enum value=""XR_VARJO_xr4_controller_interaction"" name="XR_VARJO_XR4_CONTROLLER_INTERACTION_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/varjo/xr-4_controller"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/varjo/xr-4_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/varjo/xr-4_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/varjo/xr-4_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_VARJO_extension_131" number="131" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VARJO_extension_131_SPEC_VERSION"/> + <enum value=""XR_VARJO_extension_131"" name="XR_VARJO_extension_131_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VARJO_extension_132" number="132" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VARJO_extension_132_SPEC_VERSION"/> + <enum value=""XR_VARJO_extension_132"" name="XR_VARJO_extension_132_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_133" number="133" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_133_SPEC_VERSION"/> + <enum value=""XR_ML_extension_133"" name="XR_ML_extension_133_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_134" number="134" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_134_SPEC_VERSION"/> + <enum value=""XR_ML_extension_134"" name="XR_ML_extension_134_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_ml2_controller_interaction" number="135" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="1" name="XR_ML_ml2_controller_interaction_SPEC_VERSION"/> + <enum value=""XR_ML_ml2_controller_interaction"" name="XR_ML_ML2_CONTROLLER_INTERACTION_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/ml/ml2_controller"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/ml/ml2_controller"> + <component subpath="/input/trackpad/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/trackpad/dpad_center" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/ml/ml2_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/ml/ml2_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_ML_frame_end_info" number="136" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ML_frame_end_info_SPEC_VERSION"/> + <enum value=""XR_ML_frame_end_info"" name="XR_ML_FRAME_END_INFO_EXTENSION_NAME"/> + <type name="XrFrameEndInfoML"/> + <type name="XrFrameEndInfoFlagsML"/> + <type name="XrFrameEndInfoFlagBitsML"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_FRAME_END_INFO_ML"/> + </require> + </extension> + + <extension name="XR_ML_global_dimmer" number="137" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ML_global_dimmer_SPEC_VERSION"/> + <enum value=""XR_ML_global_dimmer"" name="XR_ML_GLOBAL_DIMMER_EXTENSION_NAME"/> + <type name="XrGlobalDimmerFrameEndInfoML"/> + <type name="XrGlobalDimmerFrameEndInfoFlagsML"/> + <type name="XrGlobalDimmerFrameEndInfoFlagBitsML"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_GLOBAL_DIMMER_FRAME_END_INFO_ML"/> + </require> + </extension> + + <extension name="XR_ML_compat" number="138" type="instance" supported="openxr" protect="XR_USE_PLATFORM_ML"> + <require> + <enum value="1" name="XR_ML_compat_SPEC_VERSION"/> + <enum value=""XR_ML_compat"" name="XR_ML_COMPAT_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COORDINATE_SPACE_CREATE_INFO_ML"/> + <command name="xrCreateSpaceFromCoordinateFrameUIDML"/> + <type name="XrCoordinateSpaceCreateInfoML"/> + </require> + </extension> + + <extension name="XR_ML_marker_understanding" number="139" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ML_marker_understanding_SPEC_VERSION"/> + <enum value=""XR_ML_marker_understanding"" name="XR_ML_MARKER_UNDERSTANDING_EXTENSION_NAME"/> + + <type name="XrMarkerML"/> + <type name="XrMarkerDetectorML"/> + + <type name="XrMarkerDetectorProfileML"/> + <type name="XrMarkerTypeML"/> + <type name="XrMarkerArucoDictML"/> + <type name="XrMarkerAprilTagDictML"/> + <type name="XrMarkerDetectorFpsML"/> + <type name="XrMarkerDetectorResolutionML"/> + <type name="XrMarkerDetectorCameraML"/> + <type name="XrMarkerDetectorCornerRefineMethodML"/> + <type name="XrMarkerDetectorFullAnalysisIntervalML"/> + <type name="XrMarkerDetectorStatusML"/> + + <type name="XrSystemMarkerUnderstandingPropertiesML"/> + <type name="XrMarkerDetectorCreateInfoML"/> + <type name="XrMarkerDetectorArucoInfoML"/> + <type name="XrMarkerDetectorSizeInfoML"/> + <type name="XrMarkerDetectorAprilTagInfoML"/> + <type name="XrMarkerDetectorCustomProfileInfoML"/> + <type name="XrMarkerDetectorSnapshotInfoML"/> + <type name="XrMarkerDetectorStateML"/> + <type name="XrMarkerSpaceCreateInfoML"/> + + <command name="xrCreateMarkerDetectorML"/> + <command name="xrDestroyMarkerDetectorML"/> + <command name="xrSnapshotMarkerDetectorML"/> + <command name="xrGetMarkerDetectorStateML"/> + <command name="xrGetMarkersML"/> + <command name="xrGetMarkerReprojectionErrorML"/> + <command name="xrGetMarkerLengthML"/> + <command name="xrGetMarkerNumberML"/> + <command name="xrGetMarkerStringML"/> + <command name="xrCreateMarkerSpaceML"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_MARKER_DETECTOR_ML" comment="XrMarkerDetectorML"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_MARKER_UNDERSTANDING_PROPERTIES_ML"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_MARKER_DETECTOR_CREATE_INFO_ML"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_MARKER_DETECTOR_ARUCO_INFO_ML"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_MARKER_DETECTOR_SIZE_INFO_ML"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_MARKER_DETECTOR_APRIL_TAG_INFO_ML"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_MARKER_DETECTOR_CUSTOM_PROFILE_INFO_ML"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_MARKER_DETECTOR_SNAPSHOT_INFO_ML"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_MARKER_DETECTOR_STATE_ML"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_MARKER_SPACE_CREATE_INFO_ML"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_MARKER_DETECTOR_PERMISSION_DENIED_ML" comment="The com.magicleap.permission.MARKER_TRACKING permission was denied."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_MARKER_DETECTOR_LOCATE_FAILED_ML" comment="The specified marker could not be located spatially."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_MARKER_DETECTOR_INVALID_DATA_QUERY_ML" comment="The marker queried does not contain data of the requested type."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_MARKER_DETECTOR_INVALID_CREATE_INFO_ML" comment="pname:createInfo contains mutually exclusive parameters, such as setting ename:XR_MARKER_DETECTOR_CORNER_REFINE_METHOD_APRIL_TAG_ML with ename:XR_MARKER_TYPE_ARUCO_ML."/> + <enum offset="4" dir="-" extends="XrResult" name="XR_ERROR_MARKER_INVALID_ML" comment="The marker id passed to the function was invalid."/> + + </require> + </extension> + + <extension name="XR_ML_localization_map" number="140" type="instance" depends="XR_VERSION_1_0+XR_EXT_uuid" supported="openxr"> + <require> + <enum value="1" name="XR_ML_localization_map_SPEC_VERSION"/> + <enum value=""XR_ML_localization_map"" name="XR_ML_LOCALIZATION_MAP_EXTENSION_NAME"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_EXPORTED_LOCALIZATION_MAP_ML" comment="XrExportedLocalizationMapML"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_LOCALIZATION_MAP_ML"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_LOCALIZATION_CHANGED_ML"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_MAP_LOCALIZATION_REQUEST_INFO_ML"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_LOCALIZATION_MAP_IMPORT_INFO_ML"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_LOCALIZATION_ENABLE_EVENTS_INFO_ML"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_LOCALIZATION_MAP_INCOMPATIBLE_ML" comment="The localization map being imported is not compatible with current OS or mode."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_LOCALIZATION_MAP_UNAVAILABLE_ML" comment="The localization map requested is not available."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_LOCALIZATION_MAP_FAIL_ML" comment="The map localization service failed to fulfill the request, retry later."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_LOCALIZATION_MAP_IMPORT_EXPORT_PERMISSION_DENIED_ML" comment="The com.magicleap.permission.SPACE_IMPORT_EXPORT permission was denied."/> + <enum offset="4" dir="-" extends="XrResult" name="XR_ERROR_LOCALIZATION_MAP_PERMISSION_DENIED_ML" comment="The com.magicleap.permission.SPACE_MANAGER permission was denied."/> + <enum offset="5" dir="-" extends="XrResult" name="XR_ERROR_LOCALIZATION_MAP_ALREADY_EXISTS_ML" comment="The map being imported already exists in the system."/> + <enum offset="6" dir="-" extends="XrResult" name="XR_ERROR_LOCALIZATION_MAP_CANNOT_EXPORT_CLOUD_MAP_ML" comment="The map localization service cannot export cloud based maps."/> + + <enum offset="0" extends="XrReferenceSpaceType" name="XR_REFERENCE_SPACE_TYPE_LOCALIZATION_MAP_ML"/> + + <enum value="64" name="XR_MAX_LOCALIZATION_MAP_NAME_LENGTH_ML"/> + + <type name="XrLocalizationMapStateML"/> + <type name="XrLocalizationMapTypeML"/> + <type name="XrLocalizationMapConfidenceML"/> + + <type name="XrLocalizationMapML"/> + <type name="XrExportedLocalizationMapML"/> + <type name="XrEventDataLocalizationChangedML"/> + <type name="XrLocalizationMapQueryInfoBaseHeaderML"/> + <type name="XrMapLocalizationRequestInfoML"/> + <type name="XrLocalizationMapImportInfoML"/> + <type name="XrLocalizationEnableEventsInfoML"/> + <type name="XrLocalizationMapErrorFlagsML"/> + <type name="XrLocalizationMapErrorFlagBitsML"/> + + <command name="xrEnableLocalizationEventsML"/> + <command name="xrQueryLocalizationMapsML"/> + <command name="xrRequestMapLocalizationML"/> + <command name="xrImportLocalizationMapML"/> + + <command name="xrCreateExportedLocalizationMapML"/> + <command name="xrDestroyExportedLocalizationMapML"/> + <command name="xrGetExportedLocalizationMapDataML"/> + </require> + </extension> + + <extension name="XR_ML_spatial_anchors" number="141" type="instance" depends="XR_EXT_future" supported="openxr"> + <require> + <enum value="1" name="XR_ML_spatial_anchors_SPEC_VERSION"/> + <enum value=""XR_ML_spatial_anchors"" name="XR_ML_SPATIAL_ANCHORS_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_POSE_ML"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_CREATE_SPATIAL_ANCHORS_COMPLETION_ML"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_STATE_ML"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHORS_PERMISSION_DENIED_ML" comment="The com.magicleap.permission.SPATIAL_ANCHOR permission was not granted."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHORS_NOT_LOCALIZED_ML" comment="Operation failed because the system is not localized into a localization map."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHORS_OUT_OF_MAP_BOUNDS_ML" comment="Operation failed because it is performed outside of the localization map."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHORS_SPACE_NOT_LOCATABLE_ML" comment="Operation failed because the space referenced cannot be located."/> + + + <type name="XrSpatialAnchorsCreateInfoBaseHeaderML"/> + <type name="XrSpatialAnchorsCreateInfoFromPoseML"/> + <type name="XrCreateSpatialAnchorsCompletionML"/> + <type name="XrSpatialAnchorStateML"/> + <type name="XrSpatialAnchorConfidenceML"/> + + <command name="xrCreateSpatialAnchorsAsyncML"/> + <command name="xrCreateSpatialAnchorsCompleteML"/> + <command name="xrGetSpatialAnchorStateML"/> + + </require> + </extension> + + <extension name="XR_ML_spatial_anchors_storage" number="142" type="instance" depends="XR_EXT_future+XR_ML_spatial_anchors" supported="openxr"> + <require> + <enum value="1" name="XR_ML_spatial_anchors_storage_SPEC_VERSION"/> + <enum value=""XR_ML_spatial_anchors_storage"" name="XR_ML_SPATIAL_ANCHORS_STORAGE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SPATIAL_ANCHORS_STORAGE_ML" comment="XrSpatialAnchorsStorageML"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHORS_ANCHOR_NOT_FOUND_ML" comment="The anchor references was not found."/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_CREATE_STORAGE_INFO_ML"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_QUERY_INFO_RADIUS_ML"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_QUERY_COMPLETION_ML"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_CREATE_INFO_FROM_UUIDS_ML"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_PUBLISH_INFO_ML"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_PUBLISH_COMPLETION_ML"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_DELETE_INFO_ML"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_DELETE_COMPLETION_ML"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_INFO_ML"/> + <enum offset="9" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_COMPLETION_ML"/> + <enum offset="10" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_PUBLISH_COMPLETION_DETAILS_ML"/> + <enum offset="11" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_DELETE_COMPLETION_DETAILS_ML"/> + <enum offset="12" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHORS_UPDATE_EXPIRATION_COMPLETION_DETAILS_ML"/> + + <type name="XrSpatialAnchorsStorageML"/> + <type name="XrSpatialAnchorsCreateStorageInfoML"/> + <type name="XrSpatialAnchorsQueryInfoBaseHeaderML"/> + <type name="XrSpatialAnchorsQueryInfoRadiusML"/> + <type name="XrSpatialAnchorsQueryCompletionML"/> + <type name="XrSpatialAnchorsCreateInfoFromUuidsML"/> + <type name="XrSpatialAnchorsPublishInfoML"/> + <type name="XrSpatialAnchorsPublishCompletionML"/> + <type name="XrSpatialAnchorsDeleteInfoML"/> + <type name="XrSpatialAnchorsDeleteCompletionML"/> + <type name="XrSpatialAnchorsUpdateExpirationInfoML"/> + <type name="XrSpatialAnchorsUpdateExpirationCompletionML"/> + <type name="XrSpatialAnchorsPublishCompletionDetailsML"/> + <type name="XrSpatialAnchorsDeleteCompletionDetailsML"/> + <type name="XrSpatialAnchorsUpdateExpirationCompletionDetailsML"/> + <type name="XrSpatialAnchorCompletionResultML"/> + + <command name="xrCreateSpatialAnchorsStorageML"/> + <command name="xrDestroySpatialAnchorsStorageML"/> + <command name="xrQuerySpatialAnchorsAsyncML"/> + <command name="xrQuerySpatialAnchorsCompleteML"/> + <command name="xrPublishSpatialAnchorsAsyncML"/> + <command name="xrPublishSpatialAnchorsCompleteML"/> + <command name="xrDeleteSpatialAnchorsAsyncML"/> + <command name="xrDeleteSpatialAnchorsCompleteML"/> + <command name="xrUpdateSpatialAnchorsExpirationAsyncML"/> + <command name="xrUpdateSpatialAnchorsExpirationCompleteML"/> + + </require> + </extension> + + <extension name="XR_ML_user_calibration" number="473" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ML_user_calibration_SPEC_VERSION"/> + <enum value=""XR_ML_user_calibration"" name="XR_ML_USER_CALIBRATION_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_HEADSET_FIT_CHANGED_ML"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_EYE_CALIBRATION_CHANGED_ML"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_USER_CALIBRATION_ENABLE_EVENTS_INFO_ML"/> + + <type name="XrHeadsetFitStatusML"/> + <type name="XrEyeCalibrationStatusML"/> + + <type name="XrEventDataHeadsetFitChangedML"/> + <type name="XrEventDataEyeCalibrationChangedML"/> + <type name="XrUserCalibrationEnableEventsInfoML"/> + + <command name="xrEnableUserCalibrationEventsML"/> + + </require> + </extension> + + <extension name="XR_MSFT_spatial_anchor_persistence" number="143" depends="XR_VERSION_1_0+XR_MSFT_spatial_anchor" type="instance" supported="openxr" obsoletedby="XR_EXT_spatial_persistence"> + <require> + <enum value="2" name="XR_MSFT_spatial_anchor_persistence_SPEC_VERSION"/> + <enum value=""XR_MSFT_spatial_anchor_persistence"" name="XR_MSFT_SPATIAL_ANCHOR_PERSISTENCE_EXTENSION_NAME"/> + + <type name="XrSpatialAnchorStoreConnectionMSFT"/> + <type name="XrSpatialAnchorPersistenceNameMSFT"/> + <type name="XrSpatialAnchorPersistenceInfoMSFT"/> + <type name="XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT"/> + + <command name="xrCreateSpatialAnchorStoreConnectionMSFT"/> + <command name="xrDestroySpatialAnchorStoreConnectionMSFT"/> + <command name="xrPersistSpatialAnchorMSFT"/> + <command name="xrEnumeratePersistedSpatialAnchorNamesMSFT"/> + <command name="xrCreateSpatialAnchorFromPersistedNameMSFT"/> + <command name="xrUnpersistSpatialAnchorMSFT"/> + <command name="xrClearSpatialAnchorStoreMSFT"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SPATIAL_ANCHOR_STORE_CONNECTION_MSFT" comment="XrSpatialAnchorStoreConnectionMSFT"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_PERSISTENCE_INFO_MSFT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_FROM_PERSISTED_ANCHOR_CREATE_INFO_MSFT"/> + + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHOR_NAME_NOT_FOUND_MSFT" comment="A spatial anchor was not found associated with the spatial anchor name provided"/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHOR_NAME_INVALID_MSFT" comment="The spatial anchor name provided was not valid"/> + + <enum value="256" name="XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_MSFT"/> + </require> + </extension> + <extension name="XR_MSFT_extension_144" number="144" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_144_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_144"" name="XR_MSFT_extension_144_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_145" number="145" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_145_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_145"" name="XR_MSFT_extension_145_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_146" number="146" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_146_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_146"" name="XR_MSFT_extension_146_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_147" number="147" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_147_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_147"" name="XR_MSFT_extension_147_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_scene_marker" number="148" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_MSFT_scene_understanding" obsoletedby="XR_EXT_spatial_marker_tracking"> + <require> + <enum value="1" name="XR_MSFT_scene_marker_SPEC_VERSION"/> + <enum value=""XR_MSFT_scene_marker"" name="XR_MSFT_SCENE_MARKER_EXTENSION_NAME"/> + <type name="XrSceneMarkerTypeMSFT"/> + <type name="XrSceneMarkerQRCodeSymbolTypeMSFT"/> + <type name="XrSceneMarkerMSFT"/> + <type name="XrSceneMarkersMSFT"/> + <type name="XrSceneMarkerTypeFilterMSFT"/> + <type name="XrSceneMarkerQRCodeMSFT"/> + <type name="XrSceneMarkerQRCodesMSFT"/> + <enum offset="0" extends="XrSceneComputeFeatureMSFT" name="XR_SCENE_COMPUTE_FEATURE_MARKER_MSFT"/> + <enum offset="0" extends="XrSceneComponentTypeMSFT" name="XR_SCENE_COMPONENT_TYPE_MARKER_MSFT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SCENE_MARKERS_MSFT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SCENE_MARKER_TYPE_FILTER_MSFT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SCENE_MARKER_QR_CODES_MSFT"/> + <enum offset="0" extends="XrResult" name="XR_SCENE_MARKER_DATA_NOT_STRING_MSFT" comment="Marker does not encode a string."/> + <command name="xrGetSceneMarkerRawDataMSFT"/> + <command name="xrGetSceneMarkerDecodedStringMSFT"/> + </require> + </extension> + + <extension name="XR_KHR_extended_struct_name_lengths" number="149" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="2" name="XR_KHR_extended_struct_name_lengths_SPEC_VERSION"/> + <enum value=""XR_KHR_extended_struct_name_lengths"" name="XR_KHR_EXTENDED_STRUCT_NAME_LENGTHS_EXTENSION_NAME"/> + <command name="xrStructureTypeToString2KHR"/> + <enum value="256" name="XR_MAX_STRUCTURE_NAME_SIZE_EXTENDED_KHR"/> + </require> + </extension> + + <extension name="XR_ULTRALEAP_hand_tracking_forearm" number="150" depends="XR_VERSION_1_0+XR_EXT_hand_tracking" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ULTRALEAP_hand_tracking_forearm_SPEC_VERSION"/> + <enum value=""XR_ULTRALEAP_hand_tracking_forearm"" name="XR_ULTRALEAP_HAND_TRACKING_FOREARM_EXTENSION_NAME"/> + + <type name="XrHandForearmJointULTRALEAP"/> + <type name="XR_HAND_FOREARM_JOINT_COUNT_ULTRALEAP"/> + + <enum offset="0" extends="XrHandJointSetEXT" name="XR_HAND_JOINT_SET_HAND_WITH_FOREARM_ULTRALEAP"/> + </require> + </extension> + + <extension name="XR_ULTRALEAP_extension_151" number="151" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ULTRALEAP_extension_151_SPEC_VERSION"/> + <enum value=""XR_ULTRALEAP_extension_151"" name="XR_ULTRALEAP_extension_151_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ULTRALEAP_extension_152" number="152" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ULTRALEAP_extension_152_SPEC_VERSION"/> + <enum value=""XR_ULTRALEAP_extension_152"" name="XR_ULTRALEAP_extension_152_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ULTRALEAP_extension_153" number="153" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ULTRALEAP_extension_153_SPEC_VERSION"/> + <enum value=""XR_ULTRALEAP_extension_153"" name="XR_ULTRALEAP_extension_153_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ULTRALEAP_extension_154" number="154" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ULTRALEAP_extension_154_SPEC_VERSION"/> + <enum value=""XR_ULTRALEAP_extension_154"" name="XR_ULTRALEAP_extension_154_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ULTRALEAP_extension_155" number="155" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ULTRALEAP_extension_155_SPEC_VERSION"/> + <enum value=""XR_ULTRALEAP_extension_155"" name="XR_ULTRALEAP_extension_155_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_156" number="156" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_156_SPEC_VERSION"/> + <enum value=""XR_FB_extension_156"" name="XR_FB_extension_156_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_spatial_entity_query" number="157" type="instance" depends="XR_VERSION_1_0+XR_FB_spatial_entity_storage" supported="openxr"> + <require> + <enum value="1" name="XR_FB_spatial_entity_query_SPEC_VERSION"/> + <enum value=""XR_FB_spatial_entity_query"" name="XR_FB_SPATIAL_ENTITY_QUERY_EXTENSION_NAME"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPACE_QUERY_INFO_FB"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPACE_QUERY_RESULTS_FB"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPACE_STORAGE_LOCATION_FILTER_INFO_FB"/> + <enum offset="54" extends="XrStructureType" name="XR_TYPE_SPACE_UUID_FILTER_INFO_FB"/> + <enum offset="52" extends="XrStructureType" name="XR_TYPE_SPACE_COMPONENT_FILTER_INFO_FB"/> + <enum offset="103" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPACE_QUERY_RESULTS_AVAILABLE_FB"/> + <enum offset="104" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPACE_QUERY_COMPLETE_FB"/> + + <type name="XrSpaceQueryActionFB"/> + + <type name="XrSpaceQueryInfoBaseHeaderFB"/> + <type name="XrSpaceFilterInfoBaseHeaderFB"/> + <type name="XrSpaceQueryInfoFB"/> + <type name="XrSpaceStorageLocationFilterInfoFB"/> + <type name="XrSpaceUuidFilterInfoFB"/> + <type name="XrSpaceComponentFilterInfoFB"/> + <type name="XrSpaceQueryResultFB"/> + <type name="XrSpaceQueryResultsFB"/> + + <type name="XrEventDataSpaceQueryResultsAvailableFB"/> + <type name="XrEventDataSpaceQueryCompleteFB"/> + + <command name="xrQuerySpacesFB"/> + <command name="xrRetrieveSpaceQueryResultsFB"/> + </require> + </extension> + + <extension name="XR_FB_extension_158" number="158" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_158_SPEC_VERSION"/> + <enum value=""XR_FB_extension_158"" name="XR_FB_extension_158_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_spatial_entity_storage" number="159" type="instance" depends="XR_VERSION_1_0+XR_FB_spatial_entity" supported="openxr"> + <require> + <enum value="1" name="XR_FB_spatial_entity_storage_SPEC_VERSION"/> + <enum value=""XR_FB_spatial_entity_storage"" name="XR_FB_SPATIAL_ENTITY_STORAGE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPACE_SAVE_INFO_FB"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPACE_ERASE_INFO_FB"/> + <enum offset="106" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPACE_SAVE_COMPLETE_FB"/> + <enum offset="107" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPACE_ERASE_COMPLETE_FB"/> + + <type name="XrSpaceStorageLocationFB"/> + <type name="XrSpacePersistenceModeFB"/> + + <type name="XrSpaceSaveInfoFB"/> + <type name="XrSpaceEraseInfoFB"/> + + <type name="XrEventDataSpaceSaveCompleteFB"/> + <type name="XrEventDataSpaceEraseCompleteFB"/> + + <command name="xrSaveSpaceFB"/> + <command name="xrEraseSpaceFB"/> + </require> + </extension> + + <extension name="XR_OCULUS_audio_device_guid" number="160" type="instance" supported="openxr" protect="XR_USE_PLATFORM_WIN32"> + <require> + <enum value="1" name="XR_OCULUS_audio_device_guid_SPEC_VERSION"/> + <enum value=""XR_OCULUS_audio_device_guid"" name="XR_OCULUS_AUDIO_DEVICE_GUID_EXTENSION_NAME"/> + <enum value="128" name="XR_MAX_AUDIO_DEVICE_STR_SIZE_OCULUS"/> + <command name="xrGetAudioOutputDeviceGuidOculus"/> + <command name="xrGetAudioInputDeviceGuidOculus"/> + </require> + </extension> + + <extension name="XR_FB_foveation_vulkan" number="161" type="instance" depends="XR_VERSION_1_0+XR_FB_foveation" protect="XR_USE_GRAPHICS_API_VULKAN" supported="openxr"> + <require> + <enum value="1" name="XR_FB_foveation_vulkan_SPEC_VERSION"/> + <enum value=""XR_FB_foveation_vulkan"" name="XR_FB_FOVEATION_VULKAN_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_IMAGE_FOVEATION_VULKAN_FB"/> + + <type name="XrSwapchainImageFoveationVulkanFB"/> + </require> + </extension> + + <extension name="XR_FB_swapchain_update_state_android_surface" number="162" type="instance" supported="openxr" protect="XR_USE_PLATFORM_ANDROID" depends="XR_VERSION_1_0+XR_KHR_android_surface_swapchain+XR_FB_swapchain_update_state"> + <require> + <enum value="1" name="XR_FB_swapchain_update_state_android_surface_SPEC_VERSION"/> + <enum value=""XR_FB_swapchain_update_state_android_surface"" name="XR_FB_SWAPCHAIN_UPDATE_STATE_ANDROID_SURFACE_EXTENSION_NAME"/> + <type name="XrSwapchainStateAndroidSurfaceDimensionsFB"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_STATE_ANDROID_SURFACE_DIMENSIONS_FB"/> + </require> + </extension> + + <extension name="XR_FB_swapchain_update_state_opengl_es" number="163" type="instance" supported="openxr" protect="XR_USE_GRAPHICS_API_OPENGL_ES" depends="XR_KHR_opengl_es_enable+XR_FB_swapchain_update_state"> + <require> + <enum value="1" name="XR_FB_swapchain_update_state_opengl_es_SPEC_VERSION"/> + <enum value=""XR_FB_swapchain_update_state_opengl_es"" name="XR_FB_SWAPCHAIN_UPDATE_STATE_OPENGL_ES_EXTENSION_NAME"/> + <type name="XrSwapchainStateSamplerOpenGLESFB"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_STATE_SAMPLER_OPENGL_ES_FB"/> + </require> + </extension> + + <extension name="XR_FB_swapchain_update_state_vulkan" number="164" type="instance" supported="openxr" protect="XR_USE_GRAPHICS_API_VULKAN" depends="XR_VERSION_1_0+XR_KHR_vulkan_enable+XR_FB_swapchain_update_state"> + <require> + <enum value="1" name="XR_FB_swapchain_update_state_vulkan_SPEC_VERSION"/> + <enum value=""XR_FB_swapchain_update_state_vulkan"" name="XR_FB_SWAPCHAIN_UPDATE_STATE_VULKAN_EXTENSION_NAME"/> + <type name="XrSwapchainStateSamplerVulkanFB"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_STATE_SAMPLER_VULKAN_FB"/> + </require> + </extension> + + <extension name="XR_FB_extension_165" number="165" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_165_SPEC_VERSION"/> + <enum value=""XR_FB_extension_165"" name="XR_FB_extension_165_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_KHR_swapchain_usage_input_attachment_bit" number="166" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="3" name="XR_KHR_swapchain_usage_input_attachment_bit_SPEC_VERSION"/> + <enum value=""XR_KHR_swapchain_usage_input_attachment_bit"" name="XR_KHR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_EXTENSION_NAME"/> + <enum extends="XrSwapchainUsageFlagBits" name="XR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_KHR" alias="XR_SWAPCHAIN_USAGE_INPUT_ATTACHMENT_BIT_MND" comment="Specifies that the image may: be used as a input attachment."/> + </require> + </extension> + + <extension name="XR_FB_extension_167" number="167" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_167_SPEC_VERSION"/> + <enum value=""XR_FB_extension_167"" name="XR_FB_extension_167_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_touch_controller_pro" number="168" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="1" name="XR_FB_touch_controller_pro_SPEC_VERSION"/> + <enum value=""XR_FB_touch_controller_pro"" name="XR_FB_TOUCH_CONTROLLER_PRO_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/facebook/touch_controller_pro"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/facebook/touch_controller_pro"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/facebook/touch_controller_pro"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/facebook/touch_controller_pro"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_FB_extension_169" number="169" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_169_SPEC_VERSION"/> + <enum value=""XR_FB_extension_169"" name="XR_FB_extension_169_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_spatial_entity_sharing" number="170" type="instance" depends="XR_VERSION_1_0+XR_FB_spatial_entity" supported="openxr"> + <require> + <enum value="1" name="XR_FB_spatial_entity_sharing_SPEC_VERSION"/> + <enum value=""XR_FB_spatial_entity_sharing"" name="XR_FB_SPATIAL_ENTITY_SHARING_EXTENSION_NAME"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPACE_SHARE_INFO_FB"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPACE_SHARE_COMPLETE_FB"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SPACE_MAPPING_INSUFFICIENT_FB" comment="Anchor import from cloud or export from device failed."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPACE_LOCALIZATION_FAILED_FB" comment="Anchors were downloaded from the cloud but failed to be imported/aligned on the device."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_SPACE_NETWORK_TIMEOUT_FB" comment="Timeout occurred while waiting for network request to complete."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_SPACE_NETWORK_REQUEST_FAILED_FB" comment="The network request failed."/> + <enum offset="4" dir="-" extends="XrResult" name="XR_ERROR_SPACE_CLOUD_STORAGE_DISABLED_FB" comment="Cloud storage is required for this operation but is currently disabled."/> + + <type name="XrSpaceShareInfoFB"/> + <type name="XrEventDataSpaceShareCompleteFB"/> + + <command name="xrShareSpacesFB"/> + </require> + </extension> + + <extension name="XR_FB_extension_171" number="171" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_171_SPEC_VERSION"/> + <enum value=""XR_FB_extension_171"" name="XR_FB_extension_171_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_space_warp" number="172" type="instance" supported="openxr" deprecatedby="XR_EXT_frame_synthesis"> + <require> + <enum value="2" name="XR_FB_space_warp_SPEC_VERSION"/> + <enum value=""XR_FB_space_warp"" name="XR_FB_SPACE_WARP_EXTENSION_NAME"/> + <type name="XrCompositionLayerSpaceWarpInfoFB"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_SPACE_WARP_INFO_FB"/> + <type name="XrSystemSpaceWarpPropertiesFB"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPACE_WARP_PROPERTIES_FB"/> + <type name="XrCompositionLayerSpaceWarpInfoFlagsFB"/> + <type name="XrCompositionLayerSpaceWarpInfoFlagBitsFB"/> + </require> + </extension> + + <extension name="XR_FB_extension_173" number="173" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_173_SPEC_VERSION"/> + <enum value=""XR_FB_extension_173"" name="XR_FB_extension_173_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_haptic_amplitude_envelope" number="174" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_haptic_amplitude_envelope_SPEC_VERSION"/> + <enum value=""XR_FB_haptic_amplitude_envelope"" name="XR_FB_HAPTIC_AMPLITUDE_ENVELOPE_EXTENSION_NAME"/> + <type name="XrHapticAmplitudeEnvelopeVibrationFB"/> + <type name="XR_MAX_HAPTIC_AMPLITUDE_ENVELOPE_SAMPLES_FB"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_HAPTIC_AMPLITUDE_ENVELOPE_VIBRATION_FB"/> + </require> + </extension> + + <extension name="XR_FB_extension_175" number="175" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_175_SPEC_VERSION"/> + <enum value=""XR_FB_extension_175"" name="XR_FB_extension_175_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_scene" number="176" type="instance" depends="XR_VERSION_1_0+XR_FB_spatial_entity" supported="openxr"> + <require> + <enum value="4" name="XR_FB_scene_SPEC_VERSION"/> + <enum value=""XR_FB_scene"" name="XR_FB_SCENE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SEMANTIC_LABELS_FB"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_ROOM_LAYOUT_FB"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_BOUNDARY_2D_FB"/> + <enum offset="10" extends="XrStructureType" name="XR_TYPE_SEMANTIC_LABELS_SUPPORT_INFO_FB"/> + + <type name="XrExtent3DfFB"/> + <type name="XrOffset3DfFB"/> + <type name="XrRect3DfFB"/> + <type name="XrSemanticLabelsFB"/> + <type name="XrRoomLayoutFB"/> + <type name="XrBoundary2DFB"/> + <type name="XrSemanticLabelsSupportInfoFB"/> + + <type name="XrSemanticLabelsSupportFlagsFB"/> + <type name="XrSemanticLabelsSupportFlagBitsFB"/> + + <command name="xrGetSpaceBoundingBox2DFB"/> + <command name="xrGetSpaceBoundingBox3DFB"/> + <command name="xrGetSpaceSemanticLabelsFB"/> + <command name="xrGetSpaceBoundary2DFB"/> + <command name="xrGetSpaceRoomLayoutFB"/> + + </require> + </extension> + + <extension name="XR_EXT_palm_pose" number="177" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="3" name="XR_EXT_palm_pose_SPEC_VERSION"/> + <enum value=""XR_EXT_palm_pose"" name="XR_EXT_PALM_POSE_EXTENSION_NAME"/> + + <!-- + Only core 1.0 interaction profiles get extended here. + Others get this pose added in a nested <require depends="XR_EXT_palm_pose"> + inside the extension and/or feature that adds them. + --> + <extend interaction_profile_path="/interaction_profiles/khr/simple_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/google/daydream_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/htc/vive_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/microsoft/motion_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/oculus/go_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/oculus/touch_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/valve/index_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_UNITY_extension_178" number="178" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_UNITY_extension_178_SPEC_VERSION"/> + <enum value=""XR_UNITY_extension_178"" name="XR_UNITY_EXTENSION_178_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_UNITY_extension_179" number="179" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_UNITY_extension_179_SPEC_VERSION"/> + <enum value=""XR_UNITY_extension_179"" name="XR_UNITY_EXTENSION_179_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_UNITY_extension_180" number="180" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_UNITY_extension_180_SPEC_VERSION"/> + <enum value=""XR_UNITY_extension_180"" name="XR_UNITY_EXTENSION_180_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_UNITY_extension_181" number="181" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_UNITY_extension_181_SPEC_VERSION"/> + <enum value=""XR_UNITY_extension_181"" name="XR_UNITY_EXTENSION_181_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_UNITY_extension_182" number="182" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_UNITY_extension_182_SPEC_VERSION"/> + <enum value=""XR_UNITY_extension_182"" name="XR_UNITY_EXTENSION_182_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_UNITY_extension_183" number="183" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_UNITY_extension_183_SPEC_VERSION"/> + <enum value=""XR_UNITY_extension_183"" name="XR_UNITY_EXTENSION_183_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_UNITY_extension_184" number="184" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_UNITY_extension_184_SPEC_VERSION"/> + <enum value=""XR_UNITY_extension_184"" name="XR_UNITY_EXTENSION_184_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_UNITY_extension_185" number="185" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_UNITY_extension_185_SPEC_VERSION"/> + <enum value=""XR_UNITY_extension_185"" name="XR_UNITY_EXTENSION_185_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_UNITY_extension_186" number="186" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_UNITY_extension_186_SPEC_VERSION"/> + <enum value=""XR_UNITY_extension_186"" name="XR_UNITY_EXTENSION_186_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LIV_extension_187" number="187" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LIV_extension_187_SPEC_VERSION"/> + <enum value=""XR_LIV_extension_187"" name="XR_LIV_EXTENSION_187_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LIV_extension_188" number="188" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LIV_extension_188_SPEC_VERSION"/> + <enum value=""XR_LIV_extension_188"" name="XR_LIV_EXTENSION_188_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LIV_extension_189" number="189" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LIV_extension_189_SPEC_VERSION"/> + <enum value=""XR_LIV_extension_189"" name="XR_LIV_EXTENSION_189_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LIV_extension_190" number="190" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LIV_extension_190_SPEC_VERSION"/> + <enum value=""XR_LIV_extension_190"" name="XR_LIV_EXTENSION_190_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LIV_extension_191" number="191" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LIV_extension_191_SPEC_VERSION"/> + <enum value=""XR_LIV_extension_191"" name="XR_LIV_EXTENSION_191_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LIV_extension_192" number="192" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LIV_extension_192_SPEC_VERSION"/> + <enum value=""XR_LIV_extension_192"" name="XR_LIV_EXTENSION_192_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LIV_extension_193" number="193" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LIV_extension_193_SPEC_VERSION"/> + <enum value=""XR_LIV_extension_193"" name="XR_LIV_EXTENSION_193_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LIV_extension_194" number="194" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LIV_extension_194_SPEC_VERSION"/> + <enum value=""XR_LIV_extension_194"" name="XR_LIV_EXTENSION_194_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LIV_extension_195" number="195" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LIV_extension_195_SPEC_VERSION"/> + <enum value=""XR_LIV_extension_195"" name="XR_LIV_EXTENSION_195_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LIV_extension_196" number="196" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LIV_extension_196_SPEC_VERSION"/> + <enum value=""XR_LIV_extension_196"" name="XR_LIV_EXTENSION_196_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ALMALENCE_digital_lens_control" number="197" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ALMALENCE_digital_lens_control_SPEC_VERSION"/> + <enum value=""XR_ALMALENCE_digital_lens_control"" name="XR_ALMALENCE_DIGITAL_LENS_CONTROL_EXTENSION_NAME"/> + + <type name="XrDigitalLensControlALMALENCE"/> + <type name="XrDigitalLensControlFlagsALMALENCE"/> + <type name="XrDigitalLensControlFlagBitsALMALENCE"/> + + <command name="xrSetDigitalLensControlALMALENCE"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_DIGITAL_LENS_CONTROL_ALMALENCE"/> + </require> + </extension> + + <extension name="XR_FB_extension_198" number="198" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_198_SPEC_VERSION"/> + <enum value=""XR_FB_extension_198"" name="XR_FB_EXTENSION_198_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_scene_capture" number="199" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_scene_capture_SPEC_VERSION"/> + <enum value=""XR_FB_scene_capture"" name="XR_FB_SCENE_CAPTURE_EXTENSION_NAME"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SCENE_CAPTURE_COMPLETE_FB"/> + <enum offset="50" extends="XrStructureType" name="XR_TYPE_SCENE_CAPTURE_REQUEST_INFO_FB"/> + + <type name="XrEventDataSceneCaptureCompleteFB"/> + <type name="XrSceneCaptureRequestInfoFB"/> + + <command name="xrRequestSceneCaptureFB"/> + + </require> + </extension> + + <extension name="XR_FB_spatial_entity_container" number="200" type="instance" depends="XR_VERSION_1_0+XR_FB_spatial_entity" supported="openxr"> + <require> + <enum value="2" name="XR_FB_spatial_entity_container_SPEC_VERSION"/> + <enum value=""XR_FB_spatial_entity_container"" name="XR_FB_SPATIAL_ENTITY_CONTAINER_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPACE_CONTAINER_FB"/> + + <type name="XrSpaceContainerFB"/> + + <command name="xrGetSpaceContainerFB"/> + </require> + </extension> + + <extension name="XR_META_foveation_eye_tracked" number="201" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_FB_foveation+XR_FB_foveation_configuration"> + <require> + <enum value="1" name="XR_META_foveation_eye_tracked_SPEC_VERSION"/> + <enum value=""XR_META_foveation_eye_tracked"" name="XR_META_FOVEATION_EYE_TRACKED_EXTENSION_NAME"/> + <enum value="2" name="XR_FOVEATION_CENTER_SIZE_META"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_FOVEATION_EYE_TRACKED_PROFILE_CREATE_INFO_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_FOVEATION_EYE_TRACKED_STATE_META"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SYSTEM_FOVEATION_EYE_TRACKED_PROPERTIES_META"/> + + <type name="XrFoveationEyeTrackedProfileCreateInfoMETA"/> + <type name="XrFoveationEyeTrackedStateMETA"/> + <type name="XrSystemFoveationEyeTrackedPropertiesMETA"/> + + <type name="XrFoveationEyeTrackedProfileCreateFlagsMETA"/> + <type name="XrFoveationEyeTrackedProfileCreateFlagBitsMETA"/> + + <type name="XrFoveationEyeTrackedStateFlagsMETA"/> + <type name="XrFoveationEyeTrackedStateFlagBitsMETA"/> + + <command name="xrGetFoveationEyeTrackedStateMETA"/> + </require> + </extension> + + <extension name="XR_FB_face_tracking" number="202" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_face_tracking_SPEC_VERSION"/> + <enum value=""XR_FB_face_tracking"" name="XR_FB_FACE_TRACKING_EXTENSION_NAME"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_FACE_TRACKER_FB" comment="XrFaceTrackerFB"/> + <type name="XrFaceTrackerFB"/> + + <type name="XrFaceExpressionFB"/> + <type name="XrFaceExpressionSetFB"/> + <type name="XrFaceConfidenceFB"/> + <type name="XR_FACE_EXPRESSSION_SET_DEFAULT_FB"/> + + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES_FB"/> + <type name="XrSystemFaceTrackingPropertiesFB"/> + + <enum offset="5" extends="XrStructureType" name="XR_TYPE_FACE_TRACKER_CREATE_INFO_FB"/> + <type name="XrFaceTrackerCreateInfoFB"/> + + <enum offset="2" extends="XrStructureType" name="XR_TYPE_FACE_EXPRESSION_INFO_FB"/> + <type name="XrFaceExpressionInfoFB"/> + + <type name="XrFaceExpressionStatusFB"/> + + <enum offset="6" extends="XrStructureType" name="XR_TYPE_FACE_EXPRESSION_WEIGHTS_FB"/> + <type name="XrFaceExpressionWeightsFB"/> + + <command name="xrCreateFaceTrackerFB"/> + <command name="xrDestroyFaceTrackerFB"/> + <command name="xrGetFaceExpressionWeightsFB"/> + </require> + </extension> + + <extension name="XR_FB_eye_tracking_social" number="203" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_eye_tracking_social_SPEC_VERSION"/> + <enum value=""XR_FB_eye_tracking_social"" name="XR_FB_EYE_TRACKING_SOCIAL_EXTENSION_NAME"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_EYE_TRACKER_FB" comment="XrEyeTrackerFB"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_EYE_TRACKER_CREATE_INFO_FB"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_EYE_GAZES_INFO_FB"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_EYE_GAZES_FB"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SYSTEM_EYE_TRACKING_PROPERTIES_FB"/> + + <type name="XrEyeTrackerFB"/> + + <type name="XrEyeGazeFB"/> + <type name="XrEyePositionFB"/> + + <type name="XrEyeTrackerCreateInfoFB"/> + <type name="XrEyeGazesInfoFB"/> + <type name="XrSystemEyeTrackingPropertiesFB"/> + <type name="XrEyeGazesFB"/> + + <command name="xrCreateEyeTrackerFB"/> + <command name="xrDestroyEyeTrackerFB"/> + <command name="xrGetEyeGazesFB"/> + </require> + </extension> + + <extension name="XR_FB_passthrough_keyboard_hands" number="204" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_FB_passthrough"> + <require> + <enum value="2" name="XR_FB_passthrough_keyboard_hands_SPEC_VERSION"/> + <enum value=""XR_FB_passthrough_keyboard_hands"" name="XR_FB_PASSTHROUGH_KEYBOARD_HANDS_EXTENSION_NAME"/> + + <enum offset="1" extends="XrPassthroughLayerPurposeFB" name="XR_PASSTHROUGH_LAYER_PURPOSE_TRACKED_KEYBOARD_HANDS_FB" comment="Passthrough layer purpose for keyboard hands presence."/> + <enum offset="2" extends="XrPassthroughLayerPurposeFB" name="XR_PASSTHROUGH_LAYER_PURPOSE_TRACKED_KEYBOARD_MASKED_HANDS_FB" comment="Passthrough layer purpose for keyboard hands presence with keyboard masked hand transitions (i.e passthrough hands rendered only when they are over the keyboard)."/> + + <enum offset="2" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_KEYBOARD_HANDS_INTENSITY_FB"/> + + <type name="XrPassthroughKeyboardHandsIntensityFB"/> + + <command name="xrPassthroughLayerSetKeyboardHandsIntensityFB"/> + </require> + </extension> + + <extension name="XR_FB_composition_layer_settings" number="205" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_composition_layer_settings_SPEC_VERSION"/> + <enum value=""XR_FB_composition_layer_settings"" name="XR_FB_COMPOSITION_LAYER_SETTINGS_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_SETTINGS_FB"/> + <type name="XrCompositionLayerSettingsFB"/> + <type name="XrCompositionLayerSettingsFlagsFB"/> + <type name="XrCompositionLayerSettingsFlagBitsFB"/> + </require> + </extension> + + <extension name="XR_FB_extension_206" number="206" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_206_SPEC_VERSION"/> + <enum value=""XR_FB_extension_206"" name="XR_FB_EXTENSION_206_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_touch_controller_proximity" number="207" type="instance" supported="openxr" obsoletedby="XR_VERSION_1_1"> + <require> + <enum value="1" name="XR_FB_touch_controller_proximity_SPEC_VERSION"/> + <enum value=""XR_FB_touch_controller_proximity"" name="XR_FB_TOUCH_CONTROLLER_PROXIMITY_EXTENSION_NAME"/> + + <extend interaction_profile_path="/interaction_profiles/oculus/touch_controller"> + <component subpath="/input/trigger/proximity_fb" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumb_fb/proximity_fb" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_FB_extension_208" number="208" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_208_SPEC_VERSION"/> + <enum value=""XR_FB_extension_208"" name="XR_FB_EXTENSION_208_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_209" number="209" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_209_SPEC_VERSION"/> + <enum value=""XR_FB_extension_209"" name="XR_FB_EXTENSION_209_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_haptic_pcm" number="210" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_haptic_pcm_SPEC_VERSION"/> + <enum value=""XR_FB_haptic_pcm"" name="XR_FB_HAPTIC_PCM_EXTENSION_NAME"/> + + <type name="XrHapticPcmVibrationFB"/> + <type name="XrDevicePcmSampleRateGetInfoFB"/> + <type name="XrDevicePcmSampleRateStateFB"/> + <type name="XR_MAX_HAPTIC_PCM_BUFFER_SIZE_FB"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_HAPTIC_PCM_VIBRATION_FB"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_DEVICE_PCM_SAMPLE_RATE_STATE_FB"/> + <enum extends="XrStructureType" name="XR_TYPE_DEVICE_PCM_SAMPLE_RATE_GET_INFO_FB" alias="XR_TYPE_DEVICE_PCM_SAMPLE_RATE_STATE_FB"/> + + <command name="xrGetDeviceSampleRateFB"/> + </require> + </extension> + + <extension name="XR_FB_extension_211" number="211" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_211_SPEC_VERSION"/> + <enum value=""XR_FB_extension_211"" name="XR_FB_EXTENSION_211_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_frame_synthesis" number="212" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_EXT_frame_synthesis_SPEC_VERSION"/> + <enum value=""XR_EXT_frame_synthesis"" name="XR_EXT_FRAME_SYNTHESIS_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_FRAME_SYNTHESIS_INFO_EXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_FRAME_SYNTHESIS_CONFIG_VIEW_EXT"/> + <type name="XrFrameSynthesisInfoEXT"/> + <type name="XrFrameSynthesisConfigViewEXT"/> + <type name="XrFrameSynthesisInfoFlagsEXT"/> + <type name="XrFrameSynthesisInfoFlagBitsEXT"/> + </require> + </extension> + + <extension name="XR_FB_composition_layer_depth_test" number="213" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_composition_layer_depth_test_SPEC_VERSION"/> + <enum value=""XR_FB_composition_layer_depth_test"" name="XR_FB_COMPOSITION_LAYER_DEPTH_TEST_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_DEPTH_TEST_FB"/> + + <type name="XrCompareOpFB"/> + <type name="XrCompositionLayerDepthTestFB"/> + + </require> + </extension> + + <extension name="XR_FB_extension_214" number="214" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_214_SPEC_VERSION"/> + <enum value=""XR_FB_extension_214"" name="XR_FB_EXTENSION_214_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_215" number="215" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_215_SPEC_VERSION"/> + <enum value=""XR_FB_extension_215"" name="XR_FB_EXTENSION_215_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_216" number="216" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_216_SPEC_VERSION"/> + <enum value=""XR_FB_extension_216"" name="XR_FB_EXTENSION_216_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_local_dimming" number="217" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_local_dimming_SPEC_VERSION"/> + <enum value=""XR_META_local_dimming"" name="XR_META_LOCAL_DIMMING_EXTENSION_NAME"/> + + <type name="XrLocalDimmingModeMETA"/> + <type name="XrLocalDimmingFrameEndInfoMETA"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_LOCAL_DIMMING_FRAME_END_INFO_META"/> + </require> + </extension> + + <extension name="XR_META_passthrough_preferences" number="218" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_passthrough_preferences_SPEC_VERSION"/> + <enum value=""XR_META_passthrough_preferences"" name="XR_META_PASSTHROUGH_PREFERENCES_EXTENSION_NAME"/> + + <type name="XrPassthroughPreferencesMETA"/> + <type name="XrPassthroughPreferenceFlagsMETA"/> + <type name="XrPassthroughPreferenceFlagBitsMETA"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_PREFERENCES_META"/> + + <command name="xrGetPassthroughPreferencesMETA"/> + </require> + </extension> + + <extension name="XR_FB_extension_219" number="219" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_219_SPEC_VERSION"/> + <enum value=""XR_FB_extension_219"" name="XR_FB_EXTENSION_219_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_virtual_keyboard" number="220" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_virtual_keyboard_SPEC_VERSION"/> + <enum value=""XR_META_virtual_keyboard"" name="XR_META_VIRTUAL_KEYBOARD_EXTENSION_NAME"/> + + <enum value="3992" name="XR_MAX_VIRTUAL_KEYBOARD_COMMIT_TEXT_SIZE_META"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_VIRTUAL_KEYBOARD_META" comment="XrVirtualKeyboardMETA"/> + + <type name="XrVirtualKeyboardLocationTypeMETA"/> + <type name="XrVirtualKeyboardInputSourceMETA"/> + + <type name="XrVirtualKeyboardMETA"/> + <type name="XrSystemVirtualKeyboardPropertiesMETA"/> + <type name="XrVirtualKeyboardCreateInfoMETA"/> + <type name="XrVirtualKeyboardSpaceCreateInfoMETA"/> + <type name="XrVirtualKeyboardLocationInfoMETA"/> + <type name="XrVirtualKeyboardModelVisibilitySetInfoMETA"/> + <type name="XrVirtualKeyboardAnimationStateMETA"/> + <type name="XrVirtualKeyboardModelAnimationStatesMETA"/> + <type name="XrVirtualKeyboardTextureDataMETA"/> + <type name="XrVirtualKeyboardInputInfoMETA"/> + <type name="XrVirtualKeyboardInputStateFlagsMETA"/> + <type name="XrVirtualKeyboardInputStateFlagBitsMETA"/> + <type name="XrVirtualKeyboardTextContextChangeInfoMETA"/> + <type name="XrEventDataVirtualKeyboardCommitTextMETA"/> + <type name="XrEventDataVirtualKeyboardBackspaceMETA"/> + <type name="XrEventDataVirtualKeyboardEnterMETA"/> + <type name="XrEventDataVirtualKeyboardShownMETA"/> + <type name="XrEventDataVirtualKeyboardHiddenMETA"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SYSTEM_VIRTUAL_KEYBOARD_PROPERTIES_META"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_VIRTUAL_KEYBOARD_CREATE_INFO_META"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_VIRTUAL_KEYBOARD_SPACE_CREATE_INFO_META"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_VIRTUAL_KEYBOARD_LOCATION_INFO_META"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_VIRTUAL_KEYBOARD_MODEL_VISIBILITY_SET_INFO_META"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_VIRTUAL_KEYBOARD_ANIMATION_STATE_META"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_VIRTUAL_KEYBOARD_MODEL_ANIMATION_STATES_META"/> + <enum offset="9" extends="XrStructureType" name="XR_TYPE_VIRTUAL_KEYBOARD_TEXTURE_DATA_META"/> + <enum offset="10" extends="XrStructureType" name="XR_TYPE_VIRTUAL_KEYBOARD_INPUT_INFO_META"/> + <enum offset="11" extends="XrStructureType" name="XR_TYPE_VIRTUAL_KEYBOARD_TEXT_CONTEXT_CHANGE_INFO_META"/> + <enum offset="14" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_COMMIT_TEXT_META"/> + <enum offset="15" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_BACKSPACE_META"/> + <enum offset="16" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_ENTER_META"/> + <enum offset="17" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_SHOWN_META"/> + <enum offset="18" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_VIRTUAL_KEYBOARD_HIDDEN_META"/> + + <command name="xrCreateVirtualKeyboardMETA"/> + <command name="xrDestroyVirtualKeyboardMETA"/> + <command name="xrCreateVirtualKeyboardSpaceMETA"/> + <command name="xrSuggestVirtualKeyboardLocationMETA"/> + <command name="xrGetVirtualKeyboardScaleMETA"/> + <command name="xrSetVirtualKeyboardModelVisibilityMETA"/> + <command name="xrGetVirtualKeyboardModelAnimationStatesMETA"/> + <command name="xrGetVirtualKeyboardDirtyTexturesMETA"/> + <command name="xrGetVirtualKeyboardTextureDataMETA"/> + <command name="xrSendVirtualKeyboardInputMETA"/> + <command name="xrChangeVirtualKeyboardTextContextMETA"/> + </require> + </extension> + + <extension name="XR_FB_extension_221" number="221" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_221_SPEC_VERSION"/> + <enum value=""XR_FB_extension_221"" name="XR_FB_EXTENSION_221_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_222" number="222" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_222_SPEC_VERSION"/> + <enum value=""XR_FB_extension_222"" name="XR_FB_EXTENSION_222_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_223" number="223" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_223_SPEC_VERSION"/> + <enum value=""XR_FB_extension_223"" name="XR_FB_EXTENSION_223_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_224" number="224" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_224_SPEC_VERSION"/> + <enum value=""XR_FB_extension_224"" name="XR_FB_EXTENSION_224_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_225" number="225" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_225_SPEC_VERSION"/> + <enum value=""XR_FB_extension_225"" name="XR_FB_EXTENSION_225_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_226" number="226" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_226_SPEC_VERSION"/> + <enum value=""XR_FB_extension_226"" name="XR_FB_EXTENSION_226_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_OCULUS_external_camera" number="227" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_OCULUS_external_camera_SPEC_VERSION"/> + <enum value=""XR_OCULUS_external_camera"" name="XR_OCULUS_EXTERNAL_CAMERA_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_EXTERNAL_CAMERA_OCULUS"/> + + <enum value="32" name="XR_MAX_EXTERNAL_CAMERA_NAME_SIZE_OCULUS"/> + + <type name="XrExternalCameraAttachedToDeviceOCULUS"/> + + <type name="XrExternalCameraIntrinsicsOCULUS"/> + <type name="XrExternalCameraExtrinsicsOCULUS"/> + <type name="XrExternalCameraOCULUS"/> + <type name="XrExternalCameraStatusFlagsOCULUS"/> + <type name="XrExternalCameraStatusFlagBitsOCULUS"/> + + <command name="xrEnumerateExternalCamerasOCULUS"/> + </require> + </extension> + + <extension name="XR_META_vulkan_swapchain_create_info" number="228" type="instance" protect="XR_USE_GRAPHICS_API_VULKAN" supported="openxr"> + <require> + <enum value="1" name="XR_META_vulkan_swapchain_create_info_SPEC_VERSION"/> + <enum value=""XR_META_vulkan_swapchain_create_info"" name="XR_META_VULKAN_SWAPCHAIN_CREATE_INFO_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_VULKAN_SWAPCHAIN_CREATE_INFO_META"/> + + <type name="XrVulkanSwapchainCreateInfoMETA"/> + </require> + </extension> + + <extension name="XR_FB_extension_229" number="229" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_229_SPEC_VERSION"/> + <enum value=""XR_FB_extension_229"" name="XR_FB_EXTENSION_229_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_230" number="230" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_230_SPEC_VERSION"/> + <enum value=""XR_FB_extension_230"" name="XR_FB_EXTENSION_230_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_231" number="231" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_231_SPEC_VERSION"/> + <enum value=""XR_FB_extension_231"" name="XR_FB_EXTENSION_231_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_232" number="232" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_232_SPEC_VERSION"/> + <enum value=""XR_FB_extension_232"" name="XR_FB_EXTENSION_232_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_performance_metrics" number="233" type="instance" supported="openxr"> + <require> + <enum value="2" name="XR_META_performance_metrics_SPEC_VERSION"/> + <enum value=""XR_META_performance_metrics"" name="XR_META_PERFORMANCE_METRICS_EXTENSION_NAME"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_PERFORMANCE_METRICS_STATE_META"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_PERFORMANCE_METRICS_COUNTER_META"/> + + <type name="XrPerformanceMetricsStateMETA"/> + <type name="XrPerformanceMetricsCounterMETA"/> + <type name="XrPerformanceMetricsCounterFlagsMETA"/> + <type name="XrPerformanceMetricsCounterFlagBitsMETA"/> + + <type name="XrPerformanceMetricsCounterUnitMETA"/> + + <command name="xrEnumeratePerformanceMetricsCounterPathsMETA"/> + <command name="xrSetPerformanceMetricsStateMETA"/> + <command name="xrGetPerformanceMetricsStateMETA"/> + <command name="xrQueryPerformanceMetricsCounterMETA"/> + </require> + </extension> + + <extension name="XR_FB_extension_234" number="234" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_234_SPEC_VERSION"/> + <enum value=""XR_FB_extension_234"" name="XR_FB_EXTENSION_234_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_235" number="235" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_235_SPEC_VERSION"/> + <enum value=""XR_FB_extension_235"" name="XR_FB_EXTENSION_235_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_236" number="236" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_236_SPEC_VERSION"/> + <enum value=""XR_FB_extension_236"" name="XR_FB_EXTENSION_236_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_237" number="237" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_237_SPEC_VERSION"/> + <enum value=""XR_FB_extension_237"" name="XR_FB_EXTENSION_237_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_238" number="238" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_238_SPEC_VERSION"/> + <enum value=""XR_FB_extension_238"" name="XR_FB_EXTENSION_238_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_spatial_entity_storage_batch" number="239" type="instance" depends="XR_VERSION_1_0+XR_FB_spatial_entity_storage" supported="openxr"> + <require> + <enum value="1" name="XR_FB_spatial_entity_storage_batch_SPEC_VERSION"/> + <enum value=""XR_FB_spatial_entity_storage_batch"" name="XR_FB_SPATIAL_ENTITY_STORAGE_BATCH_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPACE_LIST_SAVE_INFO_FB"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPACE_LIST_SAVE_COMPLETE_FB"/> + + <type name="XrSpaceListSaveInfoFB"/> + <type name="XrEventDataSpaceListSaveCompleteFB"/> + + <command name="xrSaveSpaceListFB"/> + </require> + </extension> + + <extension name="XR_FB_extension_240" number="240" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_240_SPEC_VERSION"/> + <enum value=""XR_FB_extension_240"" name="XR_FB_EXTENSION_240_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_detached_controllers" number="241" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_detached_controllers_SPEC_VERSION"/> + <enum value=""XR_META_detached_controllers"" name="XR_META_DETACHED_CONTROLLERS_EXTENSION_NAME"/> + + <extend interaction_profile_predicate="true"> + <condition> + <user_path path="/user/hand/left"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </condition> + <user_path path="/user/detached_controller_meta/left" inherit="/user/hand/left"/> + </extend> + + <extend interaction_profile_predicate="true"> + <condition> + <user_path path="/user/hand/right"/> + <component subpath="/input/grip/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </condition> + <user_path path="/user/detached_controller_meta/right" inherit="/user/hand/right"/> + </extend> + + </require> + </extension> + + <extension name="XR_FB_spatial_entity_user" number="242" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_spatial_entity_user_SPEC_VERSION"/> + <enum value=""XR_FB_spatial_entity_user"" name="XR_FB_SPATIAL_ENTITY_USER_EXTENSION_NAME"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPACE_USER_CREATE_INFO_FB"/> + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SPACE_USER_FB" comment="XrSpaceUserFB"/> + + <type name="XrSpaceUserFB"/> + <type name="XrSpaceUserIdFB"/> + <type name="XrSpaceUserCreateInfoFB"/> + + <command name="xrCreateSpaceUserFB"/> + <command name="xrGetSpaceUserIdFB"/> + <command name="xrDestroySpaceUserFB"/> + </require> + </extension> + + <extension name="XR_FB_extension_243" number="243" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_243_SPEC_VERSION"/> + <enum value=""XR_FB_extension_243"" name="XR_FB_EXTENSION_243_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_244" number="244" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_244_SPEC_VERSION"/> + <enum value=""XR_FB_extension_244"" name="XR_FB_EXTENSION_244_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_245" number="245" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_245_SPEC_VERSION"/> + <enum value=""XR_FB_extension_245"" name="XR_FB_EXTENSION_245_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_headset_id" number="246" type="instance" supported="openxr"> + <require> + <enum value="2" name="XR_META_headset_id_SPEC_VERSION"/> + <enum value=""XR_META_headset_id"" name="XR_META_HEADSET_ID_EXTENSION_NAME"/> + + <type name="XrSystemHeadsetIdPropertiesMETA"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_HEADSET_ID_PROPERTIES_META"/> + </require> + </extension> + + <extension name="XR_FB_extension_247" number="247" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_247_SPEC_VERSION"/> + <enum value=""XR_FB_extension_247"" name="XR_FB_EXTENSION_247_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_spatial_entity_discovery" number="248" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_spatial_entity_discovery_SPEC_VERSION"/> + <enum value=""XR_META_spatial_entity_discovery"" name="XR_META_SPATIAL_ENTITY_DISCOVERY_EXTENSION_NAME"/> + + <type name="XrSystemSpaceDiscoveryPropertiesMETA"/> + <type name="XrSpaceFilterBaseHeaderMETA"/> + <type name="XrSpaceDiscoveryInfoMETA"/> + <type name="XrSpaceFilterUuidMETA"/> + <type name="XrSpaceFilterComponentMETA"/> + <type name="XrSpaceDiscoveryResultMETA"/> + <type name="XrSpaceDiscoveryResultsMETA"/> + <type name="XrEventDataSpaceDiscoveryResultsAvailableMETA"/> + <type name="XrEventDataSpaceDiscoveryCompleteMETA"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPACE_DISCOVERY_PROPERTIES_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPACE_DISCOVERY_INFO_META"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPACE_FILTER_UUID_META"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SPACE_FILTER_COMPONENT_META"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_SPACE_DISCOVERY_RESULT_META"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_SPACE_DISCOVERY_RESULTS_META"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPACE_DISCOVERY_RESULTS_AVAILABLE_META"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPACE_DISCOVERY_COMPLETE_META"/> + + <command name="xrDiscoverSpacesMETA"/> + <command name="xrRetrieveSpaceDiscoveryResultsMETA"/> + </require> + </extension> + + <extension name="XR_FB_extension_249" number="249" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_249_SPEC_VERSION"/> + <enum value=""XR_FB_extension_249"" name="XR_FB_EXTENSION_249_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_250" number="250" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_250_SPEC_VERSION"/> + <enum value=""XR_FB_extension_250"" name="XR_FB_EXTENSION_250_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_251" number="251" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_251_SPEC_VERSION"/> + <enum value=""XR_FB_extension_251"" name="XR_FB_EXTENSION_251_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_252" number="252" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_252_SPEC_VERSION"/> + <enum value=""XR_FB_extension_252"" name="XR_FB_EXTENSION_252_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_hand_tracking_microgestures" number="253" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_EXT_hand_interaction"> + <require> + <enum value="1" name="XR_META_hand_tracking_microgestures_SPEC_VERSION"/> + <enum value=""XR_META_hand_tracking_microgestures"" name="XR_META_HAND_TRACKING_MICROGESTURES_EXTENSION_NAME"/> + + <extend interaction_profile_path="/interaction_profiles/ext/hand_interaction_ext"> + <component subpath="/input/swipe_left_meta/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/swipe_right_meta/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/swipe_forward_meta/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/swipe_backward_meta/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/tap_thumb_meta/click" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_FB_extension_254" number="254" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_254_SPEC_VERSION"/> + <enum value=""XR_FB_extension_254"" name="XR_FB_EXTENSION_254_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_recommended_layer_resolution" number="255" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_recommended_layer_resolution_SPEC_VERSION"/> + <enum value=""XR_META_recommended_layer_resolution"" name="XR_META_RECOMMENDED_LAYER_RESOLUTION_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_RECOMMENDED_LAYER_RESOLUTION_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_RECOMMENDED_LAYER_RESOLUTION_GET_INFO_META"/> + + <type name="XrRecommendedLayerResolutionMETA"/> + <type name="XrRecommendedLayerResolutionGetInfoMETA"/> + + <command name="xrGetRecommendedLayerResolutionMETA"/> + </require> + </extension> + + <extension name="XR_FB_extension_256" number="256" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_256_SPEC_VERSION"/> + <enum value=""XR_FB_extension_256"" name="XR_FB_EXTENSION_256_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_257" number="257" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_257_SPEC_VERSION"/> + <enum value=""XR_FB_extension_257"" name="XR_FB_EXTENSION_257_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_258" number="258" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_258_SPEC_VERSION"/> + <enum value=""XR_FB_extension_258"" name="XR_FB_EXTENSION_258_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_259" number="259" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_259_SPEC_VERSION"/> + <enum value=""XR_FB_extension_259"" name="XR_FB_EXTENSION_259_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_spatial_entity_persistence" number="260" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_spatial_entity_persistence_SPEC_VERSION"/> + <enum value=""XR_META_spatial_entity_persistence"" name="XR_META_SPATIAL_ENTITY_PERSISTENCE_EXTENSION_NAME"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SPACE_INSUFFICIENT_RESOURCES_META" comment="Resource limitation prevented this operation from executing. Recommend retrying, perhaps after a short delay and/or reducing memory consumption."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPACE_STORAGE_AT_CAPACITY_META" comment="Operation could not be completed until resources used are reduced or storage expanded."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_SPACE_INSUFFICIENT_VIEW_META" comment="Look around the environment more for space tracking to function."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_SPACE_PERMISSION_INSUFFICIENT_META" comment="Space operation permission insufficient. Recommend confirming the status of the required permissions needed for using Space APIs."/> + <enum offset="4" dir="-" extends="XrResult" name="XR_ERROR_SPACE_RATE_LIMITED_META" comment="Operation cancelled due to rate limiting. Recommend retrying after a short delay."/> + <enum offset="5" dir="-" extends="XrResult" name="XR_ERROR_SPACE_TOO_DARK_META" comment="Environment too dark for tracking to complete operation."/> + <enum offset="6" dir="-" extends="XrResult" name="XR_ERROR_SPACE_TOO_BRIGHT_META" comment="Environment too bright for tracking to complete operation."/> + + <type name="XrSystemSpacePersistencePropertiesMETA"/> + <type name="XrSpacesSaveInfoMETA"/> + <type name="XrEventDataSpacesSaveResultMETA"/> + <type name="XrSpacesEraseInfoMETA"/> + <type name="XrEventDataSpacesEraseResultMETA"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPACE_PERSISTENCE_PROPERTIES_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPACES_SAVE_INFO_META"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPACES_SAVE_RESULT_META"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPACES_ERASE_INFO_META"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPACES_ERASE_RESULT_META"/> + + <command name="xrSaveSpacesMETA"/> + <command name="xrEraseSpacesMETA"/> + </require> + </extension> + + <extension name="XR_FB_extension_261" number="261" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_261_SPEC_VERSION"/> + <enum value=""XR_FB_extension_261"" name="XR_FB_EXTENSION_261_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_262" number="262" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_262_SPEC_VERSION"/> + <enum value=""XR_FB_extension_262"" name="XR_FB_EXTENSION_262_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_263" number="263" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_263_SPEC_VERSION"/> + <enum value=""XR_FB_extension_263"" name="XR_FB_EXTENSION_263_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_264" number="264" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_264_SPEC_VERSION"/> + <enum value=""XR_FB_extension_264"" name="XR_FB_EXTENSION_264_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_265" number="265" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_265_SPEC_VERSION"/> + <enum value=""XR_FB_extension_265"" name="XR_FB_EXTENSION_265_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_266" number="266" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_266_SPEC_VERSION"/> + <enum value=""XR_FB_extension_266"" name="XR_FB_EXTENSION_266_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_passthrough_color_lut" number="267" type="instance" depends="XR_VERSION_1_0+XR_FB_passthrough" supported="openxr"> + <require> + <enum value="1" name="XR_META_passthrough_color_lut_SPEC_VERSION"/> + <enum value=""XR_META_passthrough_color_lut"" name="XR_META_PASSTHROUGH_COLOR_LUT_EXTENSION_NAME"/> + + <type name="XrPassthroughColorLutMETA"/> + <type name="XrPassthroughColorLutChannelsMETA"/> + <type name="XrPassthroughColorLutDataMETA"/> + <type name="XrPassthroughColorLutCreateInfoMETA"/> + <type name="XrPassthroughColorLutUpdateInfoMETA"/> + <type name="XrPassthroughColorMapLutMETA"/> + <type name="XrPassthroughColorMapInterpolatedLutMETA"/> + <type name="XrSystemPassthroughColorLutPropertiesMETA"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_PASSTHROUGH_COLOR_LUT_PROPERTIES_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_COLOR_LUT_CREATE_INFO_META"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_COLOR_LUT_UPDATE_INFO_META"/> + <enum offset="100" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_COLOR_MAP_LUT_META"/> + <enum offset="101" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_COLOR_MAP_INTERPOLATED_LUT_META"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_PASSTHROUGH_COLOR_LUT_META" comment="XrPassthroughColorLutMETA"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_PASSTHROUGH_COLOR_LUT_BUFFER_SIZE_MISMATCH_META" comment="The provided data buffer did not match the required size."/> + + <command name="xrCreatePassthroughColorLutMETA"/> + <command name="xrDestroyPassthroughColorLutMETA"/> + <command name="xrUpdatePassthroughColorLutMETA"/> + </require> + </extension> + + <extension name="XR_FB_extension_268" number="268" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_268_SPEC_VERSION"/> + <enum value=""XR_FB_extension_268"" name="XR_FB_EXTENSION_268_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_269" number="269" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_269_SPEC_VERSION"/> + <enum value=""XR_FB_extension_269"" name="XR_FB_EXTENSION_269_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_spatial_entity_mesh" number="270" type="instance" depends="XR_VERSION_1_0+XR_FB_spatial_entity" supported="openxr"> + <require> + <enum value="1" name="XR_META_spatial_entity_mesh_SPEC_VERSION"/> + <enum value=""XR_META_spatial_entity_mesh"" name="XR_META_SPATIAL_ENTITY_MESH_EXTENSION_NAME"/> + + <enum offset="0" extends="XrSpaceComponentTypeFB" name="XR_SPACE_COMPONENT_TYPE_TRIANGLE_MESH_META" comment="Triangle mesh component."/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPACE_TRIANGLE_MESH_GET_INFO_META"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPACE_TRIANGLE_MESH_META"/> + + <type name="XrSpaceTriangleMeshGetInfoMETA"/> + <type name="XrSpaceTriangleMeshMETA"/> + + <command name="xrGetSpaceTriangleMeshMETA"/> + </require> + </extension> + + <extension name="XR_FB_extension_271" number="271" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_271_SPEC_VERSION"/> + <enum value=""XR_FB_extension_271"" name="XR_FB_EXTENSION_271_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_automatic_layer_filter" number="272" type="instance" depends="XR_VERSION_1_0+XR_FB_composition_layer_settings" supported="openxr"> + <require> + <enum value="1" name="XR_META_automatic_layer_filter_SPEC_VERSION"/> + <enum value=""XR_META_automatic_layer_filter"" name="XR_META_AUTOMATIC_LAYER_FILTER_EXTENSION_NAME"/> + <enum bitpos="5" extends="XrCompositionLayerSettingsFlagBitsFB" name="XR_COMPOSITION_LAYER_SETTINGS_AUTO_LAYER_FILTER_BIT_META" comment="Indicates compositor may: automatically toggle a texture filtering mechanism to improve visual quality of layer. This must: not be the only bit set. (Added by apiext:XR_META_automatic_layer_filter)"/> + </require> + </extension> + + <extension name="XR_FB_extension_273" number="273" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_273_SPEC_VERSION"/> + <enum value=""XR_FB_extension_273"" name="XR_FB_EXTENSION_273_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_274" number="274" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_274_SPEC_VERSION"/> + <enum value=""XR_FB_extension_274"" name="XR_FB_EXTENSION_274_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_body_tracking_full_body" number="275" type="instance" supported="openxr" depends="XR_FB_body_tracking"> + <require> + <enum value="1" name="XR_META_body_tracking_full_body_SPEC_VERSION"/> + <enum value=""XR_META_body_tracking_full_body"" name="XR_META_BODY_TRACKING_FULL_BODY_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_FULL_BODY_META"/> + <enum offset="0" extends="XrBodyJointSetFB" name="XR_BODY_JOINT_SET_FULL_BODY_META" comment="Indicates that the created slink:XrBodyTrackerFB tracks the set of body joints described by elink:XrFullBodyJointMETA enum, i.e. the flink:xrLocateBodyJointsFB function returns an array of joint locations with the count of ename:XR_FULL_BODY_JOINT_COUNT_META and can be indexed using elink:XrFullBodyJointMETA. This extends the joints of ename:XR_BODY_JOINT_SET_DEFAULT_FB by also including the lower body."/> + + <type name="XrFullBodyJointMETA"/> + <type name="XrSystemPropertiesBodyTrackingFullBodyMETA"/> + </require> + </extension> + + <extension name="XR_FB_extension_276" number="276" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_276_SPEC_VERSION"/> + <enum value=""XR_FB_extension_276"" name="XR_FB_EXTENSION_276_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_277" number="277" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_277_SPEC_VERSION"/> + <enum value=""XR_FB_extension_277"" name="XR_FB_EXTENSION_277_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_278" number="278" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_278_SPEC_VERSION"/> + <enum value=""XR_FB_extension_278"" name="XR_FB_EXTENSION_278_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_279" number="279" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_279_SPEC_VERSION"/> + <enum value=""XR_FB_extension_279"" name="XR_FB_EXTENSION_279_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_touch_controller_plus" number="280" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="1" name="XR_META_touch_controller_plus_SPEC_VERSION"/> + <enum value=""XR_META_touch_controller_plus"" name="XR_META_TOUCH_CONTROLLER_PLUS_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/meta/touch_controller_plus"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_plus"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_plus"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_plus"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_FB_extension_281" number="281" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_281_SPEC_VERSION"/> + <enum value=""XR_FB_extension_281"" name="XR_FB_EXTENSION_281_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_282" number="282" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_282_SPEC_VERSION"/> + <enum value=""XR_FB_extension_282"" name="XR_FB_EXTENSION_282_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_passthrough_layer_resumed_event" number="283" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_FB_passthrough"> + <require> + <enum value="1" name="XR_META_passthrough_layer_resumed_event_SPEC_VERSION"/> + <enum value=""XR_META_passthrough_layer_resumed_event"" name="XR_META_PASSTHROUGH_LAYER_RESUMED_EVENT_EXTENSION_NAME"/> + + <type name="XrEventDataPassthroughLayerResumedMETA"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_PASSTHROUGH_LAYER_RESUMED_META"/> + </require> + </extension> + + <extension name="XR_META_body_tracking_calibration" number="284" type="instance" supported="openxr" depends="XR_FB_body_tracking"> + <require> + <enum value="1" name="XR_META_body_tracking_calibration_SPEC_VERSION"/> + <enum value=""XR_META_body_tracking_calibration"" name="XR_META_BODY_TRACKING_CALIBRATION_EXTENSION_NAME"/> + + <enum offset="2" extends="XrStructureType" name="XR_TYPE_BODY_TRACKING_CALIBRATION_INFO_META"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_BODY_TRACKING_CALIBRATION_STATUS_META"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_CALIBRATION_META"/> + <command name="xrSuggestBodyTrackingCalibrationOverrideMETA"/> + <command name="xrResetBodyTrackingCalibrationMETA"/> + + <type name="XrBodyTrackingCalibrationStatusMETA"/> + <type name="XrBodyTrackingCalibrationStateMETA"/> + <type name="XrBodyTrackingCalibrationInfoMETA"/> + <type name="XrSystemPropertiesBodyTrackingCalibrationMETA"/> + </require> + </extension> + + <extension name="XR_META_body_tracking_fidelity" number="285" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_FB_body_tracking"> + <require> + <enum value="1" name="XR_META_body_tracking_fidelity_SPEC_VERSION"/> + <enum value=""XR_META_body_tracking_fidelity"" name="XR_META_BODY_TRACKING_FIDELITY_EXTENSION_NAME"/> + + <command name="xrRequestBodyTrackingFidelityMETA"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_BODY_TRACKING_FIDELITY_STATUS_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SYSTEM_PROPERTIES_BODY_TRACKING_FIDELITY_META"/> + + <type name="XrSystemPropertiesBodyTrackingFidelityMETA"/> + <type name="XrBodyTrackingFidelityMETA"/> + <type name="XrBodyTrackingFidelityStatusMETA"/> + </require> + </extension> + + <extension name="XR_FB_extension_286" number="286" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_286_SPEC_VERSION"/> + <enum value=""XR_FB_extension_286"" name="XR_FB_EXTENSION_286_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_287" number="287" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_287_SPEC_VERSION"/> + <enum value=""XR_FB_extension_287"" name="XR_FB_EXTENSION_287_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_face_tracking2" number="288" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_FB_face_tracking2_SPEC_VERSION"/> + <enum value=""XR_FB_face_tracking2"" name="XR_FB_FACE_TRACKING2_EXTENSION_NAME"/> + + <enum offset="12" extends="XrObjectType" name="XR_OBJECT_TYPE_FACE_TRACKER2_FB" comment="XrFaceTracker2FB"/> + <type name="XrFaceTracker2FB"/> + + <type name="XrFaceExpression2FB"/> + <type name="XrFaceExpressionSet2FB"/> + <type name="XrFaceTrackingDataSource2FB"/> + <type name="XrFaceConfidence2FB"/> + + <enum offset="13" extends="XrStructureType" name="XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES2_FB"/> + <type name="XrSystemFaceTrackingProperties2FB"/> + + <enum offset="14" extends="XrStructureType" name="XR_TYPE_FACE_TRACKER_CREATE_INFO2_FB"/> + <type name="XrFaceTrackerCreateInfo2FB"/> + + <enum offset="15" extends="XrStructureType" name="XR_TYPE_FACE_EXPRESSION_INFO2_FB"/> + <type name="XrFaceExpressionInfo2FB"/> + + <enum offset="16" extends="XrStructureType" name="XR_TYPE_FACE_EXPRESSION_WEIGHTS2_FB"/> + <type name="XrFaceExpressionWeights2FB"/> + + <command name="xrCreateFaceTracker2FB"/> + <command name="xrDestroyFaceTracker2FB"/> + <command name="xrGetFaceExpressionWeights2FB"/> + </require> + </extension> + + <extension name="XR_FB_extension_289" number="289" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_289_SPEC_VERSION"/> + <enum value=""XR_FB_extension_289"" name="XR_FB_EXTENSION_289_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_290" number="290" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_290_SPEC_VERSION"/> + <enum value=""XR_FB_extension_290"" name="XR_FB_EXTENSION_290_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_spatial_entity_sharing" number="291" type="instance" supported="openxr" depends="XR_FB_spatial_entity"> + <require> + <enum value="1" name="XR_META_spatial_entity_sharing_SPEC_VERSION"/> + <enum value=""XR_META_spatial_entity_sharing"" name="XR_META_SPATIAL_ENTITY_SHARING_EXTENSION_NAME"/> + + <enum value="32" name="XR_MAX_SPACES_PER_SHARE_REQUEST_META"/> + + <type name="XrSystemSpatialEntitySharingPropertiesMETA"/> + + <type name="XrShareSpacesRecipientBaseHeaderMETA"/> + <type name="XrShareSpacesInfoMETA"/> + <type name="XrEventDataShareSpacesCompleteMETA"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPATIAL_ENTITY_SHARING_PROPERTIES_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SHARE_SPACES_INFO_META"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SHARE_SPACES_COMPLETE_META"/> + + <command name="xrShareSpacesMETA"/> + </require> + </extension> + + + <extension name="XR_META_environment_depth" number="292" type="instance" supported="openxr"> + <require> + <enum value="2" name="XR_META_environment_depth_SPEC_VERSION"/> + <enum value=""XR_META_environment_depth"" name="XR_META_ENVIRONMENT_DEPTH_EXTENSION_NAME"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_ENVIRONMENT_DEPTH_PROVIDER_META" comment="XrEnvironmentDepthProviderMETA"/> + <enum offset="1" extends="XrObjectType" name="XR_OBJECT_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_META" comment="XrEnvironmentDepthSwapchainMETA"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_DEPTH_PROVIDER_CREATE_INFO_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_CREATE_INFO_META"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_DEPTH_SWAPCHAIN_STATE_META"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_ACQUIRE_INFO_META"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_VIEW_META"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_META"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_DEPTH_HAND_REMOVAL_SET_INFO_META"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_SYSTEM_ENVIRONMENT_DEPTH_PROPERTIES_META"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_DEPTH_IMAGE_TIMESTAMP_META"/> + + <!-- Successful return codes. --> + <enum offset="0" extends="XrResult" name="XR_ENVIRONMENT_DEPTH_NOT_AVAILABLE_META" comment="Warning: The requested depth image is not yet available."/> + + <type name="XrEnvironmentDepthProviderMETA"/> + <type name="XrEnvironmentDepthSwapchainMETA"/> + <type name="XrEnvironmentDepthProviderCreateInfoMETA"/> + <type name="XrEnvironmentDepthProviderCreateFlagsMETA"/> + <type name="XrEnvironmentDepthProviderCreateFlagBitsMETA"/> + <type name="XrEnvironmentDepthSwapchainCreateFlagsMETA"/> + <type name="XrEnvironmentDepthSwapchainCreateFlagBitsMETA"/> + <type name="XrEnvironmentDepthSwapchainCreateInfoMETA"/> + <type name="XrEnvironmentDepthSwapchainStateMETA"/> + <type name="XrEnvironmentDepthImageAcquireInfoMETA"/> + <type name="XrEnvironmentDepthImageViewMETA"/> + <type name="XrEnvironmentDepthImageMETA"/> + <type name="XrEnvironmentDepthImageTimestampMETA"/> + <type name="XrEnvironmentDepthHandRemovalSetInfoMETA"/> + <type name="XrSystemEnvironmentDepthPropertiesMETA"/> + + <command name="xrCreateEnvironmentDepthProviderMETA"/> + <command name="xrDestroyEnvironmentDepthProviderMETA"/> + <command name="xrStartEnvironmentDepthProviderMETA"/> + <command name="xrStopEnvironmentDepthProviderMETA"/> + <command name="xrCreateEnvironmentDepthSwapchainMETA"/> + <command name="xrDestroyEnvironmentDepthSwapchainMETA"/> + <command name="xrEnumerateEnvironmentDepthSwapchainImagesMETA"/> + <command name="xrGetEnvironmentDepthSwapchainStateMETA"/> + <command name="xrAcquireEnvironmentDepthImageMETA"/> + <command name="xrSetEnvironmentDepthHandRemovalMETA"/> </require> + </extension> + + <extension name="XR_FB_extension_293" number="293" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_293_SPEC_VERSION"/> + <enum value=""XR_FB_extension_293"" name="XR_FB_EXTENSION_293_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_294" number="294" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_294_SPEC_VERSION"/> + <enum value=""XR_FB_extension_294"" name="XR_FB_EXTENSION_294_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_295" number="295" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_295_SPEC_VERSION"/> + <enum value=""XR_FB_extension_295"" name="XR_FB_EXTENSION_295_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_296" number="296" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_296_SPEC_VERSION"/> + <enum value=""XR_FB_extension_296"" name="XR_FB_EXTENSION_296_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_297" number="297" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_297_SPEC_VERSION"/> + <enum value=""XR_FB_extension_297"" name="XR_FB_EXTENSION_297_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_298" number="298" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_298_SPEC_VERSION"/> + <enum value=""XR_FB_extension_298"" name="XR_FB_EXTENSION_298_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_FB_extension_299" number="299" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_FB_extension_299_SPEC_VERSION"/> + <enum value=""XR_FB_extension_299"" name="XR_FB_EXTENSION_299_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_uuid" number="300" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="1" name="XR_EXT_uuid_SPEC_VERSION"/> + <enum value=""XR_EXT_uuid"" name="XR_EXT_UUID_EXTENSION_NAME"/> + <type name="XrUuidEXT"/> + <enum value="16" name="XR_UUID_SIZE_EXT"/> + </require> + </extension> + + <extension name="XR_EXT_render_model" number="301" type="instance" supported="openxr" depends="XR_VERSION_1_1,XR_EXT_uuid" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_render_model_SPEC_VERSION"/> + <enum value=""XR_EXT_render_model"" name="XR_EXT_RENDER_MODEL_EXTENSION_NAME"/> + + <type name="XrRenderModelIdEXT"/> + + <type name="XrRenderModelEXT"/> + <type name="XrRenderModelCreateInfoEXT"/> + <type name="XrRenderModelPropertiesGetInfoEXT"/> + <type name="XrRenderModelPropertiesEXT"/> + <type name="XrRenderModelSpaceCreateInfoEXT"/> + <type name="XrRenderModelStateGetInfoEXT"/> + <type name="XrRenderModelNodeStateEXT"/> + <type name="XrRenderModelStateEXT"/> + + <type name="XrRenderModelAssetEXT"/> + <type name="XrRenderModelAssetCreateInfoEXT"/> + <type name="XrRenderModelAssetDataGetInfoEXT"/> + <type name="XrRenderModelAssetDataEXT"/> + <type name="XrRenderModelAssetPropertiesGetInfoEXT"/> + <type name="XrRenderModelAssetNodePropertiesEXT"/> + <type name="XrRenderModelAssetPropertiesEXT"/> + + <command name="xrCreateRenderModelEXT"/> + <command name="xrDestroyRenderModelEXT"/> + <command name="xrGetRenderModelPropertiesEXT"/> + <command name="xrCreateRenderModelSpaceEXT"/> + <command name="xrCreateRenderModelAssetEXT"/> + <command name="xrDestroyRenderModelAssetEXT"/> + <command name="xrGetRenderModelAssetDataEXT"/> + <command name="xrGetRenderModelAssetPropertiesEXT"/> + <command name="xrGetRenderModelStateEXT"/> + + <enum value="0" name="XR_NULL_RENDER_MODEL_ID_EXT"/> + <enum value="64" name="XR_MAX_RENDER_MODEL_ASSET_NODE_NAME_SIZE_EXT"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_RENDER_MODEL_EXT" comment="XrRenderModelEXT"/> + <enum offset="1" extends="XrObjectType" name="XR_OBJECT_TYPE_RENDER_MODEL_ASSET_EXT" comment="XrRenderModelAssetEXT"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_CREATE_INFO_EXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_PROPERTIES_GET_INFO_EXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_PROPERTIES_EXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_SPACE_CREATE_INFO_EXT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_STATE_GET_INFO_EXT"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_STATE_EXT"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_ASSET_CREATE_INFO_EXT"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_ASSET_DATA_GET_INFO_EXT"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_ASSET_DATA_EXT"/> + <enum offset="9" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_ASSET_PROPERTIES_GET_INFO_EXT"/> + <enum offset="10" extends="XrStructureType" name="XR_TYPE_RENDER_MODEL_ASSET_PROPERTIES_EXT"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_RENDER_MODEL_ID_INVALID_EXT" comment="The render model ID is invalid."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_RENDER_MODEL_ASSET_UNAVAILABLE_EXT" comment="The render model asset is unavailable."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_RENDER_MODEL_GLTF_EXTENSION_REQUIRED_EXT" comment="A glTF extension is required."/> + </require> + </extension> + + <extension name="XR_EXT_interaction_render_model" number="302" type="instance" supported="openxr" depends="XR_EXT_render_model" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_interaction_render_model_SPEC_VERSION"/> + <enum value=""XR_EXT_interaction_render_model"" name="XR_EXT_INTERACTION_RENDER_MODEL_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_INTERACTION_RENDER_MODEL_IDS_ENUMERATE_INFO_EXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_INTERACTION_RENDER_MODEL_SUBACTION_PATH_INFO_EXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_INTERACTION_RENDER_MODELS_CHANGED_EXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_INTERACTION_RENDER_MODEL_TOP_LEVEL_USER_PATH_GET_INFO_EXT"/> + + <type name="XrInteractionRenderModelIdsEnumerateInfoEXT"/> + <type name="XrInteractionRenderModelSubactionPathInfoEXT"/> + <type name="XrInteractionRenderModelTopLevelUserPathGetInfoEXT"/> + <type name="XrEventDataInteractionRenderModelsChangedEXT"/> + <command name="xrEnumerateInteractionRenderModelIdsEXT"/> + <command name="xrEnumerateRenderModelSubactionPathsEXT"/> + <command name="xrGetRenderModelPoseTopLevelUserPathEXT"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_NOT_INTERACTION_RENDER_MODEL_EXT" comment="The provided slink:XrRenderModelEXT was not created from a basetype:XrRenderModelIdEXT from `<<XR_EXT_interaction_render_model>>`"/> + </require> + </extension> + + <extension name="XR_EXT_hand_interaction" number="303" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="2" name="XR_EXT_hand_interaction_SPEC_VERSION"/> + <enum value=""XR_EXT_hand_interaction"" name="XR_EXT_HAND_INTERACTION_EXTENSION_NAME"/> + + <interaction_profile name="/interaction_profiles/ext/hand_interaction_ext"/> + + <!-- + Only core 1.0 interaction profiles get extended here. + Others get this pose added in a nested <require depends="XR_EXT_hand_interaction"> + inside the extension and/or feature that adds them. + --> + <extend interaction_profile_path="/interaction_profiles/khr/simple_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/google/daydream_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/htc/vive_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/microsoft/motion_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/oculus/go_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/oculus/touch_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/valve/index_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/ext/hand_interaction_ext"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_QCOM_image_tracking" number="304" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_image_tracking_SPEC_VERSION"/> + <enum value=""XR_QCOM_image_tracking"" name="XR_QCOM_IMAGE_TRACKING_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_object_tracking" number="305" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_object_tracking_SPEC_VERSION"/> + <enum value=""XR_QCOM_object_tracking"" name="XR_QCOM_OBJECT_TRACKING_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_plane_detection" number="306" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_plane_detection_SPEC_VERSION"/> + <enum value=""XR_QCOM_plane_detection"" name="XR_QCOM_PLANE_DETECTION_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_tracking_optimization_settings" number="307" type="instance" supported="openxr"> + <require> + <enum value="2" name="XR_QCOM_tracking_optimization_settings_SPEC_VERSION"/> + <enum value=""XR_QCOM_tracking_optimization_settings"" name="XR_QCOM_TRACKING_OPTIMIZATION_SETTINGS_EXTENSION_NAME"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_HINT_ALREADY_SET_QCOM" comment="Tracking optimization hint is already set for the domain."/> + + <type name="XrTrackingOptimizationSettingsDomainQCOM"/> + <type name="XrTrackingOptimizationSettingsHintQCOM"/> + + <enum extends="XrTrackingOptimizationSettingsHintQCOM" name="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LONG_RANGE_PRIORIZATION_QCOM" alias="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LONG_RANGE_PRIORITIZATION_QCOM" comment="Backward-compatibility alias containing typo."/> + <enum extends="XrTrackingOptimizationSettingsHintQCOM" name="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_CLOSE_RANGE_PRIORIZATION_QCOM" alias="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_CLOSE_RANGE_PRIORITIZATION_QCOM" comment="Backward-compatibility alias containing typo."/> + <enum extends="XrTrackingOptimizationSettingsHintQCOM" name="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LOW_POWER_PRIORIZATION_QCOM" alias="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_LOW_POWER_PRIORITIZATION_QCOM" comment="Backward-compatibility alias containing typo."/> + <enum extends="XrTrackingOptimizationSettingsHintQCOM" name="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_HIGH_POWER_PRIORIZATION_QCOM" alias="XR_TRACKING_OPTIMIZATION_SETTINGS_HINT_HIGH_POWER_PRIORITIZATION_QCOM" comment="Backward-compatibility alias containing typo."/> + + <command name="xrSetTrackingOptimizationSettingsHintQCOM"/> + </require> + </extension> + + <extension name="XR_QCOM_ray_casting" number="308" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_ray_casting_SPEC_VERSION"/> + <enum value=""XR_QCOM_ray_casting"" name="XR_QCOM_RAY_CASTING_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_309" number="309" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_309_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_309"" name="XR_QCOM_EXTENSION_309_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_310" number="310" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_310_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_310"" name="XR_QCOM_EXTENSION_310_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_hand_tracking_gesture" number="311" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_EXT_hand_tracking" deprecatedby="XR_EXT_hand_interaction"> + <require> + <enum value="1" name="XR_QCOM_hand_tracking_gesture_SPEC_VERSION"/> + <enum value=""XR_QCOM_hand_tracking_gesture"" name="XR_QCOM_HAND_TRACKING_GESTURE_EXTENSION_NAME"/> + + <type name="XrHandGestureTypeQCOM"/> + <type name="XrHandGestureQCOM"/> + + <command name="xrGetHandGestureQCOM"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_312" number="312" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_312_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_312"" name="XR_QCOM_EXTENSION_312_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_313" number="313" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_313_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_313"" name="XR_QCOM_EXTENSION_313_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_314" number="314" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_314_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_314"" name="XR_QCOM_EXTENSION_314_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_315" number="315" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_315_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_315"" name="XR_QCOM_EXTENSION_315_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_316" number="316" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_316_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_316"" name="XR_QCOM_EXTENSION_316_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_317" number="317" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_317_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_317"" name="XR_QCOM_EXTENSION_317_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_passthrough" number="318" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_HTC_passthrough_SPEC_VERSION"/> + <enum value=""XR_HTC_passthrough"" name="XR_HTC_PASSTHROUGH_EXTENSION_NAME"/> + + <type name="XrPassthroughHTC"/> + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_PASSTHROUGH_HTC" comment="XrPassthroughHTC"/> + + <type name="XrPassthroughFormHTC"/> + + <type name="XrPassthroughCreateInfoHTC"/> + <type name="XrPassthroughColorHTC"/> + <type name="XrPassthroughMeshTransformInfoHTC"/> + <type name="XrCompositionLayerPassthroughHTC"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_CREATE_INFO_HTC"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_COLOR_HTC"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_MESH_TRANSFORM_INFO_HTC"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_HTC"/> + + <command name="xrCreatePassthroughHTC"/> + <command name="xrDestroyPassthroughHTC"/> + </require> + </extension> + + <extension name="XR_HTC_foveation" number="319" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_HTC_foveation_SPEC_VERSION"/> + <enum value=""XR_HTC_foveation"" name="XR_HTC_FOVEATION_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_FOVEATION_APPLY_INFO_HTC"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_FOVEATION_DYNAMIC_MODE_INFO_HTC"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_FOVEATION_CUSTOM_MODE_INFO_HTC"/> + + <type name="XrFoveationModeHTC"/> + <type name="XrFoveationLevelHTC"/> + + <type name="XrFoveationApplyInfoHTC"/> + <type name="XrFoveationConfigurationHTC"/> + <type name="XrFoveationDynamicModeInfoHTC"/> + <type name="XrFoveationCustomModeInfoHTC"/> + <type name="XrFoveationDynamicFlagsHTC"/> + <type name="XrFoveationDynamicFlagBitsHTC"/> + + <command name="xrApplyFoveationHTC"/> + </require> + </extension> + + <extension name="XR_HTC_anchor" number="320" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_HTC_anchor_SPEC_VERSION"/> + <enum value=""XR_HTC_anchor"" name="XR_HTC_ANCHOR_EXTENSION_NAME"/> + <enum value="256" name="XR_MAX_SPATIAL_ANCHOR_NAME_SIZE_HTC"/> + <type name="XrSystemAnchorPropertiesHTC"/> + <type name="XrSpatialAnchorCreateInfoHTC"/> + <type name="XrSpatialAnchorNameHTC"/> + <command name="xrCreateSpatialAnchorHTC"/> + <command name="xrGetSpatialAnchorNameHTC"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_ANCHOR_PROPERTIES_HTC"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_HTC"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_NOT_AN_ANCHOR_HTC" comment="The provided space is valid but not an anchor."/> + </require> + </extension> + + <extension name="XR_HTC_body_tracking" number="321" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_HTC_body_tracking_SPEC_VERSION"/> + <enum value=""XR_HTC_body_tracking"" name="XR_HTC_BODY_TRACKING_EXTENSION_NAME"/> + + <command name="xrCreateBodyTrackerHTC"/> + <command name="xrDestroyBodyTrackerHTC"/> + <command name="xrLocateBodyJointsHTC"/> + <command name="xrGetBodySkeletonHTC"/> + + <type name="XrBodyJointHTC"/> + <type name="XrBodyJointSetHTC"/> + <type name="XrBodyJointConfidenceHTC"/> + + <type name="XrBodyTrackerHTC"/> + <type name="XrSystemBodyTrackingPropertiesHTC"/> + <type name="XrBodyTrackerCreateInfoHTC"/> + <type name="XrBodyJointsLocateInfoHTC"/> + <type name="XrBodyJointLocationsHTC"/> + <type name="XrBodyJointLocationHTC"/> + <type name="XrBodySkeletonHTC"/> + <type name="XrBodySkeletonJointHTC"/> + + <type name="XR_BODY_JOINT_COUNT_HTC"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_BODY_TRACKER_HTC" comment="XrBodyTrackerHTC"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_HTC"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_BODY_TRACKER_CREATE_INFO_HTC"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_BODY_JOINTS_LOCATE_INFO_HTC"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_BODY_JOINT_LOCATIONS_HTC"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_BODY_SKELETON_HTC"/> + </require> + </extension> + + <extension name="XR_HTC_extension_322" number="322" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_322_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_322"" name="XR_HTC_extension_322_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_323" number="323" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_323_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_323"" name="XR_HTC_extension_323_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_324" number="324" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_324_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_324"" name="XR_HTC_extension_324_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_325" number="325" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_325_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_325"" name="XR_HTC_extension_325_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_326" number="326" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_326_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_326"" name="XR_HTC_extension_326_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_327" number="327" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_327_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_327"" name="XR_HTC_extension_327_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_328" number="328" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_328_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_328"" name="XR_HTC_extension_328_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_329" number="329" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_329_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_329"" name="XR_HTC_extension_329_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_330" number="330" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_330_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_330"" name="XR_HTC_extension_330_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_331" number="331" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_331_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_331"" name="XR_HTC_extension_331_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_332" number="332" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_332_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_332"" name="XR_HTC_extension_332_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_333" number="333" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_333_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_333"" name="XR_HTC_extension_333_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_334" number="334" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_334_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_334"" name="XR_HTC_extension_334_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_335" number="335" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_335_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_335"" name="XR_HTC_extension_335_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_336" number="336" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_336_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_336"" name="XR_HTC_extension_336_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_337" number="337" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_337_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_337"" name="XR_HTC_extension_337_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_338" number="338" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_338_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_338"" name="XR_HTC_extension_338_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_339" number="339" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_339_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_339"" name="XR_HTC_extension_339_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_340" number="340" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_340_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_340"" name="XR_HTC_extension_340_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_341" number="341" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_341_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_341"" name="XR_HTC_extension_341_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_342" number="342" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_342_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_342"" name="XR_HTC_extension_342_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_343" number="343" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_343_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_343"" name="XR_HTC_extension_343_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_344" number="344" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_344_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_344"" name="XR_HTC_extension_344_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_345" number="345" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_345_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_345"" name="XR_HTC_extension_345_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_346" number="346" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_346_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_346"" name="XR_HTC_extension_346_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_347" number="347" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_347_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_347"" name="XR_HTC_extension_347_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_348" number="348" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_348_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_348"" name="XR_HTC_extension_348_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_349" number="349" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_349_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_349"" name="XR_HTC_extension_349_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_350" number="350" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_350_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_350"" name="XR_HTC_extension_350_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_351" number="351" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_351_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_351"" name="XR_HTC_extension_351_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_352" number="352" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_352_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_352"" name="XR_HTC_extension_352_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_353" number="353" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_353_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_353"" name="XR_HTC_extension_353_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_354" number="354" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_354_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_354"" name="XR_HTC_extension_354_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_355" number="355" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_355_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_355"" name="XR_HTC_extension_355_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_356" number="356" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_356_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_356"" name="XR_HTC_extension_356_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_357" number="357" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_357_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_357"" name="XR_HTC_extension_357_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_358" number="358" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_358_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_358"" name="XR_HTC_extension_358_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_359" number="359" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_359_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_359"" name="XR_HTC_extension_359_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_360" number="360" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_360_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_360"" name="XR_HTC_extension_360_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_361" number="361" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_361_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_361"" name="XR_HTC_extension_361_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_362" number="362" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_362_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_362"" name="XR_HTC_extension_362_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_363" number="363" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_363_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_363"" name="XR_HTC_extension_363_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_364" number="364" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_364_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_364"" name="XR_HTC_extension_364_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_365" number="365" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_365_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_365"" name="XR_HTC_extension_365_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_366" number="366" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_366_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_366"" name="XR_HTC_extension_366_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_367" number="367" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_367_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_367"" name="XR_HTC_extension_367_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_368" number="368" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_368_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_368"" name="XR_HTC_extension_368_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_369" number="369" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_369_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_369"" name="XR_HTC_extension_369_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_HTC_extension_370" number="370" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HTC_extension_370_SPEC_VERSION"/> + <enum value=""XR_HTC_extension_370"" name="XR_HTC_extension_370_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_371" number="371" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_371_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_371"" name="XR_EXT_extension_371_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_372" number="372" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_372_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_372"" name="XR_EXT_extension_372_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_KHR_extendable_action_binding" number="373" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_KHR_extendable_action_binding_SPEC_VERSION"/> + <enum value=""XR_KHR_extendable_action_binding"" name="XR_KHR_EXTENDABLE_ACTION_BINDING_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_active_action_set_priority" number="374" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_EXT_active_action_set_priority_SPEC_VERSION"/> + <enum value=""XR_EXT_active_action_set_priority"" name="XR_EXT_ACTIVE_ACTION_SET_PRIORITY_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_ACTIVE_ACTION_SET_PRIORITIES_EXT"/> + <type name="XrActiveActionSetPrioritiesEXT"/> + <type name="XrActiveActionSetPriorityEXT"/> + </require> + </extension> + + <extension name="XR_HUAWEI_6dof_controller_interaction" number="375" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_HUAWEI_6dof_controller_interaction_SPEC_VERSION"/> + <enum value=""XR_HUAWEI_6dof_controller_interaction"" name="XR_HUAWEI_6DOF_CONTROLLER_INTERACTION_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MNDX_force_feedback_curl" number="376" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_EXT_hand_tracking" provisional="true"> + <require> + <enum value="1" name="XR_MNDX_force_feedback_curl_SPEC_VERSION"/> + <enum value=""XR_MNDX_force_feedback_curl"" name="XR_MNDX_FORCE_FEEDBACK_CURL_EXTENSION_NAME"/> + + <command name="xrApplyForceFeedbackCurlMNDX"/> + + <type name="XrSystemForceFeedbackCurlPropertiesMNDX"/> + <type name="XrForceFeedbackCurlLocationMNDX"/> + <type name="XrForceFeedbackCurlApplyLocationsMNDX"/> + <type name="XrForceFeedbackCurlApplyLocationMNDX"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_FORCE_FEEDBACK_CURL_PROPERTIES_MNDX"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_FORCE_FEEDBACK_CURL_APPLY_LOCATIONS_MNDX"/> + </require> + </extension> + + <extension name="XR_MND_extension_377" number="377" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_377_SPEC_VERSION"/> + <enum value=""XR_MND_extension_377"" name="XR_MND_extension_377_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_378" number="378" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_378_SPEC_VERSION"/> + <enum value=""XR_MND_extension_378"" name="XR_MND_extension_378_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_379" number="379" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_379_SPEC_VERSION"/> + <enum value=""XR_MND_extension_379"" name="XR_MND_extension_379_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_380" number="380" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_380_SPEC_VERSION"/> + <enum value=""XR_MND_extension_380"" name="XR_MND_extension_380_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_381" number="381" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_381_SPEC_VERSION"/> + <enum value=""XR_MND_extension_381"" name="XR_MND_extension_381_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_382" number="382" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_382_SPEC_VERSION"/> + <enum value=""XR_MND_extension_382"" name="XR_MND_extension_382_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_383" number="383" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_383_SPEC_VERSION"/> + <enum value=""XR_MND_extension_383"" name="XR_MND_extension_383_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_384" number="384" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_384_SPEC_VERSION"/> + <enum value=""XR_MND_extension_384"" name="XR_MND_extension_384_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_controller_interaction" number="385" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="2" name="XR_BD_controller_interaction_SPEC_VERSION"/> + <enum value=""XR_BD_controller_interaction"" name="XR_BD_CONTROLLER_INTERACTION_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/bytedance/pico_neo3_controller"/> + <interaction_profile name="/interaction_profiles/bytedance/pico4_controller"/> + <interaction_profile name="/interaction_profiles/bytedance/pico_g3_controller"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_neo3_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico4_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_g3_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_neo3_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico4_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_g3_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_neo3_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico4_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_g3_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_BD_body_tracking" number="386" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_body_tracking_SPEC_VERSION"/> + <enum value=""XR_BD_body_tracking"" name="XR_BD_BODY_TRACKING_EXTENSION_NAME"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_BODY_TRACKER_BD" comment="XrBodyTrackerBD"/> + <type name="XrBodyTrackerBD"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_BODY_TRACKER_CREATE_INFO_BD"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_BODY_JOINTS_LOCATE_INFO_BD"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_BODY_JOINT_LOCATIONS_BD"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SYSTEM_BODY_TRACKING_PROPERTIES_BD"/> + + <type name="XrBodyJointBD"/> + <type name="XrBodyJointSetBD"/> + + <type name="XrSystemBodyTrackingPropertiesBD"/> + <type name="XrBodyTrackerCreateInfoBD"/> + <type name="XrBodyJointsLocateInfoBD"/> + <type name="XrBodyJointLocationsBD"/> + <type name="XrBodyJointLocationBD"/> + <type name="XR_BODY_JOINT_COUNT_BD"/> + <type name="XR_BODY_JOINT_WITHOUT_ARM_COUNT_BD"/> + + + <command name="xrCreateBodyTrackerBD"/> + <command name="xrDestroyBodyTrackerBD"/> + <command name="xrLocateBodyJointsBD"/> + + </require> + </extension> + + <extension name="XR_BD_facial_simulation" number="387" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_facial_simulation_SPEC_VERSION"/> + <enum value=""XR_BD_facial_simulation"" name="XR_BD_FACIAL_SIMULATION_EXTENSION_NAME"/> + <type name="XrFaceTrackerBD"/> + <type name="XrSystemFacialSimulationPropertiesBD"/> + <type name="XrFaceTrackerCreateInfoBD"/> + <type name="XrFacialSimulationDataGetInfoBD"/> + <type name="XrFacialSimulationDataBD"/> + <type name="XrLipExpressionDataBD"/> + <type name="XrFaceExpressionBD"/> + <type name="XrLipExpressionBD"/> + <type name="XrFacialSimulationModeBD"/> + <type name="XR_FACE_EXPRESSION_COUNT_BD"/> + <type name="XR_LIP_EXPRESSION_COUNT_BD"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_FACE_TRACKER_BD" comment="XrFaceTrackerBD"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SYSTEM_FACIAL_SIMULATION_PROPERTIES_BD"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_FACE_TRACKER_CREATE_INFO_BD"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_FACIAL_SIMULATION_DATA_GET_INFO_BD"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_FACIAL_SIMULATION_DATA_BD"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_LIP_EXPRESSION_DATA_BD"/> + + <command name="xrEnumerateFacialSimulationModesBD"/> + <command name="xrCreateFaceTrackerBD"/> + <command name="xrDestroyFaceTrackerBD"/> + <command name="xrGetFacialSimulationDataBD"/> + <command name="xrSetFacialSimulationModeBD"/> + <command name="xrGetFacialSimulationModeBD"/> + </require> + </extension> + + <extension name="XR_BD_extension_388" number="388" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_388_SPEC_VERSION"/> + <enum value=""XR_BD_extension_388"" name="XR_BD_extension_388_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_389" number="389" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_389_SPEC_VERSION"/> + <enum value=""XR_BD_extension_389"" name="XR_BD_extension_389_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_spatial_sensing" number="390" depends="XR_VERSION_1_0+XR_EXT_future" type="instance" supported="openxr"> + <require> + <enum value="3" name="XR_BD_spatial_sensing_SPEC_VERSION"/> + <enum value=""XR_BD_spatial_sensing"" name="XR_BD_SPATIAL_SENSING_EXTENSION_NAME"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ENTITY_ID_INVALID_BD" comment="The spatial entity id is invalid."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_SENSING_SERVICE_UNAVAILABLE_BD" comment="The spatial sensing service is unavailable."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_ANCHOR_NOT_SUPPORTED_FOR_ENTITY_BD" comment="The spatial entity does not support anchor."/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPATIAL_SENSING_PROPERTIES_BD"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_COMPONENT_GET_INFO_BD"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_LOCATION_GET_INFO_BD"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_LOCATION_BD"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_SEMANTIC_BD"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_BOUNDING_BOX_2D_BD"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_POLYGON_BD"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_BOUNDING_BOX_3D_BD"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_TRIANGLE_MESH_BD"/> + + <enum offset="9" extends="XrStructureType" name="XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_BD"/> + <enum offset="10" extends="XrStructureType" name="XR_TYPE_SENSE_DATA_PROVIDER_START_INFO_BD"/> + <enum offset="11" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SENSE_DATA_PROVIDER_STATE_CHANGED_BD"/> + <enum offset="12" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SENSE_DATA_UPDATED_BD"/> + <enum offset="13" extends="XrStructureType" name="XR_TYPE_SENSE_DATA_QUERY_INFO_BD"/> + <enum offset="14" extends="XrStructureType" name="XR_TYPE_SENSE_DATA_QUERY_COMPLETION_BD"/> + <enum offset="15" extends="XrStructureType" name="XR_TYPE_SENSE_DATA_FILTER_UUID_BD"/> + <enum offset="16" extends="XrStructureType" name="XR_TYPE_SENSE_DATA_FILTER_SEMANTIC_BD"/> + <enum offset="17" extends="XrStructureType" name="XR_TYPE_QUERIED_SENSE_DATA_GET_INFO_BD"/> + <enum offset="18" extends="XrStructureType" name="XR_TYPE_QUERIED_SENSE_DATA_BD"/> + <enum offset="19" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_STATE_BD"/> + <enum offset="20" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_ANCHOR_CREATE_INFO_BD"/> + <enum offset="21" extends="XrStructureType" name="XR_TYPE_ANCHOR_SPACE_CREATE_INFO_BD"/> + <enum offset="22" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_SPHERE_BD"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SENSE_DATA_PROVIDER_BD" comment="XrSenseDataProviderBD"/> + <enum offset="1" extends="XrObjectType" name="XR_OBJECT_TYPE_SENSE_DATA_SNAPSHOT_BD" comment="XrSenseDataSnapshotBD"/> + <enum offset="2" extends="XrObjectType" name="XR_OBJECT_TYPE_ANCHOR_BD" comment="XrAnchorBD"/> + + <type name="XrSpatialEntityIdBD"/> + <type name="XrSpatialEntityComponentTypeBD"/> + <type name="XrSemanticLabelBD"/> + + <type name="XrSenseDataProviderBD"/> + <type name="XrSenseDataSnapshotBD"/> + <type name="XrSenseDataProviderTypeBD"/> + <type name="XrSenseDataProviderStateBD"/> + + <type name="XrSystemSpatialSensingPropertiesBD"/> + <type name="XrSpatialEntityComponentGetInfoBD"/> + <type name="XrSpatialEntityComponentDataBaseHeaderBD"/> + <type name="XrSpatialEntityLocationGetInfoBD"/> + <type name="XrSpatialEntityComponentDataLocationBD"/> + <type name="XrSpatialEntityComponentDataSemanticBD"/> + <type name="XrSpatialEntityComponentDataBoundingBox2DBD"/> + <type name="XrSpatialEntityComponentDataPolygonBD"/> + <type name="XrSpatialEntityComponentDataBoundingBox3DBD"/> + <type name="XrSpatialEntityComponentDataTriangleMeshBD"/> + <type name="XrSpatialEntityComponentDataSphereBD"/> + + <type name="XrSenseDataProviderCreateInfoBD"/> + <type name="XrSenseDataProviderStartInfoBD"/> + <type name="XrEventDataSenseDataProviderStateChangedBD"/> + <type name="XrEventDataSenseDataUpdatedBD"/> + <type name="XrSenseDataQueryInfoBD"/> + <type name="XrSenseDataQueryCompletionBD"/> + <type name="XrQueriedSenseDataGetInfoBD"/> + <type name="XrQueriedSenseDataBD"/> + <type name="XrSpatialEntityStateBD"/> + <type name="XrSenseDataFilterUuidBD"/> + <type name="XrSenseDataFilterSemanticBD"/> + + <type name="XrAnchorBD"/> + <type name="XrSpatialEntityAnchorCreateInfoBD"/> + <type name="XrAnchorSpaceCreateInfoBD"/> + + + <command name="xrEnumerateSpatialEntityComponentTypesBD"/> + <command name="xrGetSpatialEntityUuidBD"/> + <command name="xrGetSpatialEntityComponentDataBD"/> + + <command name="xrCreateSenseDataProviderBD"/> + <command name="xrStartSenseDataProviderAsyncBD"/> + <command name="xrStartSenseDataProviderCompleteBD"/> + <command name="xrGetSenseDataProviderStateBD"/> + <command name="xrQuerySenseDataAsyncBD"/> + <command name="xrQuerySenseDataCompleteBD"/> + <command name="xrDestroySenseDataSnapshotBD"/> + <command name="xrGetQueriedSenseDataBD"/> + <command name="xrStopSenseDataProviderBD"/> + <command name="xrDestroySenseDataProviderBD"/> + + <command name="xrCreateSpatialEntityAnchorBD"/> + <command name="xrDestroyAnchorBD"/> + <command name="xrGetAnchorUuidBD"/> + <command name="xrCreateAnchorSpaceBD"/> + + + </require> + </extension> + + <extension name="XR_BD_spatial_anchor" number="391" depends="XR_BD_spatial_sensing" type="instance" supported="openxr"> + <require> + <enum value="2" name="XR_BD_spatial_anchor_SPEC_VERSION"/> + <enum value=""XR_BD_spatial_anchor"" name="XR_BD_SPATIAL_ANCHOR_EXTENSION_NAME"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHOR_NOT_FOUND_BD" comment="The spatial anchor is not found."/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPATIAL_ANCHOR_PROPERTIES_BD"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_BD"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_CREATE_COMPLETION_BD"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_PERSIST_INFO_BD"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_UNPERSIST_INFO_BD"/> + + <enum offset="0" extends="XrSenseDataProviderTypeBD" name="XR_SENSE_DATA_PROVIDER_TYPE_ANCHOR_BD" comment="Create arbitrary spatial anchors."/> + + <type name="XrPersistenceLocationBD"/> + <type name="XrSystemSpatialAnchorPropertiesBD"/> + <type name="XrSpatialAnchorCreateInfoBD"/> + <type name="XrSpatialAnchorCreateCompletionBD"/> + <type name="XrSpatialAnchorPersistInfoBD"/> + <type name="XrSpatialAnchorUnpersistInfoBD"/> + + <command name="xrCreateSpatialAnchorAsyncBD"/> + <command name="xrCreateSpatialAnchorCompleteBD"/> + <command name="xrPersistSpatialAnchorAsyncBD"/> + <command name="xrPersistSpatialAnchorCompleteBD"/> + <command name="xrUnpersistSpatialAnchorAsyncBD"/> + <command name="xrUnpersistSpatialAnchorCompleteBD"/> + </require> + </extension> + + <extension name="XR_BD_spatial_anchor_sharing" number="392" depends="XR_BD_spatial_anchor" type="instance" supported="openxr"> + <require> + <enum value="2" name="XR_BD_spatial_anchor_sharing_SPEC_VERSION"/> + <enum value=""XR_BD_spatial_anchor_sharing"" name="XR_BD_SPATIAL_ANCHOR_SHARING_EXTENSION_NAME"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHOR_SHARING_NETWORK_TIMEOUT_BD" comment="The network transmission timeout."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHOR_SHARING_AUTHENTICATION_FAILURE_BD" comment="The authentication for the user account failed."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHOR_SHARING_NETWORK_FAILURE_BD" comment="The network connection failed, e.g. the connection is unstable or disconnected."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHOR_SHARING_LOCALIZATION_FAIL_BD" comment="The spatial anchor localization failed."/> + <enum offset="4" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHOR_SHARING_MAP_INSUFFICIENT_BD" comment="The feature points of spatial anchor map are insufficient."/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPATIAL_ANCHOR_SHARING_PROPERTIES_BD"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_SHARE_INFO_BD"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SHARED_SPATIAL_ANCHOR_DOWNLOAD_INFO_BD"/> + + <type name="XrSystemSpatialAnchorSharingPropertiesBD"/> + <type name="XrSpatialAnchorShareInfoBD"/> + <type name="XrSharedSpatialAnchorDownloadInfoBD"/> + + <command name="xrShareSpatialAnchorAsyncBD"/> + <command name="xrShareSpatialAnchorCompleteBD"/> + <command name="xrDownloadSharedSpatialAnchorAsyncBD"/> + <command name="xrDownloadSharedSpatialAnchorCompleteBD"/> + </require> + </extension> + + <extension name="XR_BD_spatial_scene" number="393" depends="XR_BD_spatial_sensing" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_spatial_scene_SPEC_VERSION"/> + <enum value=""XR_BD_spatial_scene"" name="XR_BD_SPATIAL_SCENE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPATIAL_SCENE_PROPERTIES_BD"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SCENE_CAPTURE_INFO_BD"/> + + <enum offset="0" extends="XrSenseDataProviderTypeBD" name="XR_SENSE_DATA_PROVIDER_TYPE_SCENE_BD" comment="Access spatial scene capture data."/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SCENE_CAPTURE_FAILURE_BD" comment="The scene capture is failed, for example exiting abnormally."/> + + <type name="XrSystemSpatialScenePropertiesBD"/> + <type name="XrSceneCaptureInfoBD"/> + + <command name="xrCaptureSceneAsyncBD"/> + <command name="xrCaptureSceneCompleteBD"/> + + </require> + </extension> + + <extension name="XR_BD_spatial_mesh" number="394" depends="XR_BD_spatial_sensing" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_spatial_mesh_SPEC_VERSION"/> + <enum value=""XR_BD_spatial_mesh"" name="XR_BD_SPATIAL_MESH_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPATIAL_MESH_PROPERTIES_BD"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_SPATIAL_MESH_BD"/> + + <enum offset="0" extends="XrSenseDataProviderTypeBD" name="XR_SENSE_DATA_PROVIDER_TYPE_MESH_BD" comment="Capture spatial mesh data."/> + + <type name="XrSystemSpatialMeshPropertiesBD"/> + <type name="XrSenseDataProviderCreateInfoSpatialMeshBD"/> + + <type name="XrSpatialMeshLodBD"/> + <type name="XrSpatialMeshConfigFlagsBD"/> + <type name="XrSpatialMeshConfigFlagBitsBD"/> + + </require> + </extension> + + <extension name="XR_BD_future_progress" number="395" type="instance" depends="XR_VERSION_1_0+XR_EXT_future" supported="openxr"> + <require> + <enum value="1" name="XR_BD_future_progress_SPEC_VERSION"/> + <enum value=""XR_BD_future_progress"" name="XR_BD_FUTURE_PROGRESS_EXTENSION_NAME"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_FUTURE_POLL_RESULT_PROGRESS_BD"/> + + <type name="XrFuturePollResultProgressBD"/> + </require> + </extension> + + <extension name="XR_BD_body_tracking_auxiliary_metrics" number="396" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_body_tracking_auxiliary_metrics_SPEC_VERSION"/> + <enum value=""XR_BD_body_tracking_auxiliary_metrics"" name="XR_BD_BODY_TRACKING_AUXILIARY_METRICS_EXTENSION_NAME"/> + + <type name="XrBodyTrackingPostureBD"/> + <type name="XrBodyTrackingPostureDataBD"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_BODY_TRACKING_POSTURE_DATA_BD"/> + + <type name="XrBodyJointVelocityBD"/> + <type name="XrBodyJointVelocitiesBD"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_BODY_JOINT_VELOCITIES_BD"/> + + <type name="XrSpaceAccelerationFlagsBD"/> + <type name="XrSpaceAccelerationFlagBitsBD"/> + <type name="XrBodyJointAccelerationBD"/> + <type name="XrBodyJointAccelerationsBD"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_BODY_JOINT_ACCELERATIONS_BD"/> + + <type name="XrBodyTrackingStatusBD"/> + <type name="XrBodyTrackingMessageBD"/> + + <type name="XrBodyTrackingStateBD"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_BODY_TRACKING_STATE_BD"/> + + <command name="xrStartBodyTrackingCalibrationAppBD"/> + <command name="xrGetBodyTrackingStateBD"/> + </require> + </extension> + + <extension name="XR_BD_spatial_plane" number="397" depends="XR_BD_spatial_sensing" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_spatial_plane_SPEC_VERSION"/> + <enum value=""XR_BD_spatial_plane"" name="XR_BD_SPATIAL_PLANE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPATIAL_PLANE_PROPERTIES_BD" comment="XrSystemSpatialPlanePropertiesBD"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_PLANE_ORIENTATION_BD" comment="XrSpatialEntityComponentDataPlaneOrientationBD"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SENSE_DATA_FILTER_PLANE_ORIENTATION_BD" comment="XrSenseDataFilterPlaneOrientationBD"/> + + <enum offset="0" extends="XrSenseDataProviderTypeBD" name="XR_SENSE_DATA_PROVIDER_TYPE_PLANE_BD" comment="Capture spatial plane data."/> + <enum offset="0" extends="XrSpatialEntityComponentTypeBD" name="XR_SPATIAL_ENTITY_COMPONENT_TYPE_PLANE_ORIENTATION_BD" comment="The plane orientation. Corresponds to component data structure slink:XrSpatialEntityComponentDataPlaneOrientationBD."/> + + <type name="XrSystemSpatialPlanePropertiesBD"/> + <type name="XrPlaneOrientationBD"/> + <type name="XrSpatialEntityComponentDataPlaneOrientationBD"/> + <type name="XrSenseDataFilterPlaneOrientationBD"/> + </require> + </extension> + + <extension name="XR_BD_spatial_light_estimation" number="398" depends="XR_BD_spatial_sensing" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_spatial_light_estimation_SPEC_VERSION"/> + <enum value=""XR_BD_spatial_light_estimation"" name="XR_BD_SPATIAL_LIGHT_ESTIMATION_EXTENSION_NAME"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_LIGHT_ESTIMATION_PROPERTIES_BD"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_LIGHT_ESTIMATION_BD"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_TEXTURE_CREATE_CONFIG_INFO_BD"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_LIGHT_ESTIMATION_DATA_ENVIRONMENT_TEXTURE_RAW_BD"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_LIGHT_ESTIMATION_DATA_SPHERICAL_HARMONICS_BD"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_LIGHT_ESTIMATION_BD"/> + <enum offset="0" extends="XrSpatialEntityComponentTypeBD" name="XR_SPATIAL_ENTITY_COMPONENT_TYPE_LIGHT_ESTIMATION_BD" comment="The light estimate data. Corresponds to component data structure slink:XrSpatialEntityComponentDataLightEstimationBD."/> + <enum offset="0" extends="XrSenseDataProviderTypeBD" name="XR_SENSE_DATA_PROVIDER_TYPE_LIGHT_ESTIMATION_BD" comment="Access spatial light estimate data."/> + + <type name="XrSystemLightEstimationPropertiesBD"/> + <type name="XrLightEstimationCreateFlagsBD"/> + <type name="XrLightEstimationCreateFlagBitsBD"/> + <type name="XrSenseDataProviderCreateInfoLightEstimationBD"/> + <type name="XrEnvironmentTextureCreateConfigInfoBD"/> + <type name="XrLightEstimationDataEnvironmentTextureRawBD"/> + <type name="XrLightEstimationDataSphericalHarmonicsBD"/> + <type name="XrSpatialEntityComponentDataLightEstimationBD"/> + + <type name="XrEnvironmentTexturePixelFormatBD"/> + <type name="XrEnvironmentTextureResolutionBD"/> + <type name="XrEnvironmentTextureTransferTypeBD"/> + <type name="XrSphericalHarmonicsKindBD"/> + + <command name="xrEnumerateEnvironmentTextureResolutionsBD"/> + <command name="xrEnumerateEnvironmentTexturePixelFormatsBD"/> + <command name="xrEnumerateEnvironmentTextureTransferTypesBD"/> + </require> + </extension> + + <extension name="XR_BD_extension_399" number="399" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_399_SPEC_VERSION"/> + <enum value=""XR_BD_extension_399"" name="XR_BD_extension_399_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_400" number="400" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_400_SPEC_VERSION"/> + <enum value=""XR_BD_extension_400"" name="XR_BD_extension_400_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_401" number="401" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_401_SPEC_VERSION"/> + <enum value=""XR_BD_extension_401"" name="XR_BD_extension_401_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_402" number="402" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_402_SPEC_VERSION"/> + <enum value=""XR_BD_extension_402"" name="XR_BD_extension_402_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_403" number="403" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_403_SPEC_VERSION"/> + <enum value=""XR_BD_extension_403"" name="XR_BD_extension_403_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_ultra_controller_interaction" number="404" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_ultra_controller_interaction_SPEC_VERSION"/> + <enum value=""XR_BD_ultra_controller_interaction"" name="XR_BD_ULTRA_CONTROLLER_INTERACTION_EXTENSION_NAME"/> + + <interaction_profile name="/interaction_profiles/bytedance/pico_ultra_controller_bd"/> + </require> + + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_ultra_controller_bd"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_ultra_controller_bd"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_ultra_controller_bd"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + + </extension> + + <extension name="XR_BD_extension_405" number="405" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_405_SPEC_VERSION"/> + <enum value=""XR_BD_extension_405"" name="XR_BD_extension_405_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_406" number="406" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_406_SPEC_VERSION"/> + <enum value=""XR_BD_extension_406"" name="XR_BD_extension_406_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_407" number="407" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_407_SPEC_VERSION"/> + <enum value=""XR_BD_extension_407"" name="XR_BD_extension_407_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_408" number="408" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_408_SPEC_VERSION"/> + <enum value=""XR_BD_extension_408"" name="XR_BD_extension_408_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_409" number="409" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_409_SPEC_VERSION"/> + <enum value=""XR_BD_extension_409"" name="XR_BD_extension_409_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_spatial_audio_rendering" number="410" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_spatial_audio_rendering_SPEC_VERSION"/> + <enum value=""XR_BD_spatial_audio_rendering"" name="XR_BD_SPATIAL_AUDIO_RENDERING_EXTENSION_NAME"/> + + <!-- Structs --> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_AUDIO_RENDERER_CREATE_INFO_BD"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_AUDIO_BUFFER_BD"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SOUND_OBJECT_DIRECTIVITY_CARDIOID_BD"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SOUND_OBJECT_SHAPE_SPHERE_BD"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_SOUND_OBJECT_DISTANCE_ATTENUATION_BD"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_SOUND_OBJECT_DISTANCE_ATTENUATION_CURVE_BD"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_SOUND_OBJECT_CONFIG_BD"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_SOUND_FIELD_CONFIG_BD"/> + <enum offset="9" extends="XrStructureType" name="XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_SURROUND_BD"/> + <enum offset="10" extends="XrStructureType" name="XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_AMBIX_BD"/> + <enum offset="11" extends="XrStructureType" name="XR_TYPE_SOUND_FIELD_CHANNEL_DEFINITION_FUMA_BD"/> + <enum offset="12" extends="XrStructureType" name="XR_TYPE_SOUND_TRIANGLE_MESH_BD"/> + <enum offset="13" extends="XrStructureType" name="XR_TYPE_SOUND_OBSTACLE_CONFIG_BD"/> + <enum offset="14" extends="XrStructureType" name="XR_TYPE_SOUND_OBSTACLE_MATERIAL_CONFIG_BD"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SPATIAL_AUDIO_RENDERER_BD" comment="XrSpatialAudioRendererBD"/> + <enum offset="1" extends="XrObjectType" name="XR_OBJECT_TYPE_SOUND_FIELD_BD" comment="XrSoundFieldBD"/> + <enum offset="2" extends="XrObjectType" name="XR_OBJECT_TYPE_SOUND_OBJECT_BD" comment="XrSoundObjectBD"/> + <enum offset="3" extends="XrObjectType" name="XR_OBJECT_TYPE_SOUND_OBSTACLE_BD" comment="XrSoundObstacleBD"/> + <enum offset="4" extends="XrObjectType" name="XR_OBJECT_TYPE_SOUND_OBSTACLE_MATERIAL_BD" comment="XrSoundObstacleMaterialBD"/> + + <type name="XrSpatialAudioRendererBD"/> + <type name="XrSoundFieldBD"/> + <type name="XrSoundObjectBD"/> + <type name="XrSoundObstacleBD"/> + <type name="XrSoundObstacleMaterialBD"/> + + <type name="XrSpatialAudioRendererCreateInfoBD"/> + <type name="XrAudioBufferBD"/> + <type name="XrSoundObjectDirectivityCardioidBD"/> + <type name="XrSoundObjectShapeSphereBD"/> + <type name="XrSoundObjectDistanceAttenuationBD"/> + <type name="XrSoundObjectDistanceAttenuationCurveBD"/> + <type name="XrSoundObjectConfigBD"/> + <type name="XrSoundFieldConfigBD"/> + <type name="XrSoundFieldChannelDefinitionSurroundBD"/> + <type name="XrSoundFieldChannelDefinitionAmbixBD"/> + <type name="XrSoundFieldChannelDefinitionFumaBD"/> + <type name="XrSoundFieldChannelMaskSurroundBD"/> + <type name="XrSoundTriangleMeshBD"/> + <type name="XrSoundObstacleConfigBD"/> + <type name="XrSoundObstacleMaterialConfigBD"/> + <type name="XrAttenuationCurvePointBD"/> + <type name="XrAudioSampleRateBD"/> + <type name="XrAudioBufferChannelLayoutBD"/> + <type name="XrSoundObstacleMaterialTypeBD"/> + <type name="XrSoundObjectDistanceAttenuationTypeBD"/> + <type name="XrSoundObstacleFlagsBD"/> + <type name="XrSoundObstacleFlagBitsBD"/> + <type name="XrSoundObjectFlagsBD"/> + <type name="XrSoundObjectFlagBitsBD"/> + <type name="XrSoundFieldChannelMaskSurroundBD"/> + <type name="XrSoundFieldChannelMaskAmbixBD"/> + <type name="XrSoundFieldChannelMaskFumaBD"/> + <type name="XrSoundFieldFlagsBD"/> + <type name="XrSoundFieldFlagBitsBD"/> + + <command name="xrEnumerateSupportedAudioSampleRateBD"/> + <command name="xrQueryFramesPerBufferRangeBD"/> + <command name="xrCreateSpatialAudioRendererBD"/> + <command name="xrDestroySpatialAudioRendererBD"/> + <command name="xrCreateSoundObstacleMaterialBD"/> + <command name="xrUpdateSoundObstacleMaterialConfigBD"/> + <command name="xrDestroySoundObstacleMaterialBD"/> + <command name="xrCreateSoundObstacleBD"/> + <command name="xrUpdateSoundObstacleConfigBD"/> + <command name="xrDestroySoundObstacleBD"/> + <command name="xrCreateSoundObjectBD"/> + <command name="xrUpdateSoundObjectConfigBD"/> + <command name="xrSubmitSoundObjectBufferBD"/> + <command name="xrDestroySoundObjectBD"/> + <command name="xrCreateSoundFieldBD"/> + <command name="xrUpdateSoundFieldConfigBD"/> + <command name="xrSubmitSoundFieldBufferBD"/> + <command name="xrDestroySoundFieldBD"/> + <command name="xrWaitAudioPeriodBD"/> + <command name="xrEndAudioPeriodBD"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_411" number="411" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_411_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_411"" name="XR_MSFT_EXTENSION_411_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_412" number="412" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_412_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_412"" name="XR_MSFT_EXTENSION_412_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_413" number="413" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_413_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_413"" name="XR_MSFT_EXTENSION_413_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_414" number="414" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_414_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_414"" name="XR_MSFT_EXTENSION_414_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_415" number="415" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_415_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_415"" name="XR_MSFT_EXTENSION_415_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_416" number="416" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_416_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_416"" name="XR_MSFT_EXTENSION_416_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_417" number="417" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_417_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_417"" name="XR_MSFT_EXTENSION_417_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_418" number="418" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_418_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_418"" name="XR_MSFT_EXTENSION_418_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_419" number="419" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_419_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_419"" name="XR_MSFT_EXTENSION_419_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_420" number="420" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_420_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_420"" name="XR_MSFT_EXTENSION_420_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MSFT_extension_421" number="421" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MSFT_extension_421_SPEC_VERSION"/> + <enum value=""XR_MSFT_extension_421"" name="XR_MSFT_EXTENSION_421_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_DANWILLM_extension_422" number="422" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_DANWILLM_extension_422_SPEC_VERSION"/> + <enum value=""XR_DANWILLM_extension_422"" name="XR_DANWILLM_EXTENSION_422_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_DANWILLM_extension_423" number="423" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_DANWILLM_extension_423_SPEC_VERSION"/> + <enum value=""XR_DANWILLM_extension_423"" name="XR_DANWILLM_EXTENSION_423_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_DANWILLM_extension_424" number="424" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_DANWILLM_extension_424_SPEC_VERSION"/> + <enum value=""XR_DANWILLM_extension_424"" name="XR_DANWILLM_EXTENSION_424_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_DANWILLM_extension_425" number="425" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_DANWILLM_extension_425_SPEC_VERSION"/> + <enum value=""XR_DANWILLM_extension_425"" name="XR_DANWILLM_EXTENSION_425_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_DANWILLM_extension_426" number="426" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_DANWILLM_extension_426_SPEC_VERSION"/> + <enum value=""XR_DANWILLM_extension_426"" name="XR_DANWILLM_EXTENSION_426_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_local_floor" number="427" type="instance" supported="openxr" promotedto="XR_VERSION_1_1"> + <require> + <enum value="1" name="XR_EXT_local_floor_SPEC_VERSION"/> + <enum value=""XR_EXT_local_floor"" name="XR_EXT_LOCAL_FLOOR_EXTENSION_NAME"/> + <enum extends="XrReferenceSpaceType" name="XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR_EXT" alias="XR_REFERENCE_SPACE_TYPE_LOCAL_FLOOR"/> + </require> + </extension> + + <extension name="XR_LOGITECH_extension_428" number="428" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LOGITECH_extension_428_SPEC_VERSION"/> + <enum value=""XR_LOGITECH_extension_428"" name="XR_LOGITECH_EXTENSION_428_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_hand_tracking_data_source" number="429" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_EXT_hand_tracking" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_hand_tracking_data_source_SPEC_VERSION"/> + <enum value=""XR_EXT_hand_tracking_data_source"" name="XR_EXT_HAND_TRACKING_DATA_SOURCE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_HAND_TRACKING_DATA_SOURCE_INFO_EXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_HAND_TRACKING_DATA_SOURCE_STATE_EXT"/> + + <type name="XrHandTrackingDataSourceEXT"/> + <type name="XrHandTrackingDataSourceInfoEXT"/> + <type name="XrHandTrackingDataSourceStateEXT"/> + </require> + </extension> + + <extension name="XR_EXT_plane_detection" number="430" type="instance" supported="openxr" deprecatedby="XR_EXT_spatial_plane_tracking"> + <require> + <enum value="2" name="XR_EXT_plane_detection_SPEC_VERSION"/> + <enum value=""XR_EXT_plane_detection"" name="XR_EXT_PLANE_DETECTION_EXTENSION_NAME"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SPACE_NOT_LOCATABLE_EXT" comment="The space passed to the function was not locatable."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_PLANE_DETECTION_PERMISSION_DENIED_EXT" comment="The permission for this resource was not granted."/> + + <command name="xrCreatePlaneDetectorEXT"/> + <command name="xrDestroyPlaneDetectorEXT"/> + <command name="xrBeginPlaneDetectionEXT"/> + <command name="xrGetPlaneDetectionStateEXT"/> + <command name="xrGetPlaneDetectionsEXT"/> + <command name="xrGetPlanePolygonBufferEXT"/> + + <type name="XrSystemPlaneDetectionPropertiesEXT"/> + <type name="XrPlaneDetectionCapabilityFlagsEXT"/> + <type name="XrPlaneDetectionCapabilityFlagBitsEXT"/> + <type name="XrPlaneDetectorEXT"/> + <type name="XrPlaneDetectorCreateInfoEXT"/> + <type name="XrPlaneDetectorBeginInfoEXT"/> + <type name="XrPlaneDetectionStateEXT"/> + <type name="XrPlaneDetectorGetInfoEXT"/> + <type name="XrPlaneDetectorLocationEXT"/> + <type name="XrPlaneDetectorLocationsEXT"/> + <type name="XrPlaneDetectorPolygonBufferEXT"/> + <type name="XrPlaneDetectorFlagsEXT"/> + <type name="XrPlaneDetectorFlagBitsEXT"/> + <type name="XrPlaneDetectorSemanticTypeEXT"/> + <type name="XrPlaneDetectorOrientationEXT"/> + <type name="XrExtent3DfEXT"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_PLANE_DETECTOR_EXT" comment="XrPlaneDetectorEXT"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_PLANE_DETECTOR_CREATE_INFO_EXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_PLANE_DETECTOR_BEGIN_INFO_EXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_PLANE_DETECTOR_GET_INFO_EXT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_PLANE_DETECTOR_LOCATIONS_EXT"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_PLANE_DETECTOR_LOCATION_EXT"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_PLANE_DETECTOR_POLYGON_BUFFER_EXT"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_SYSTEM_PLANE_DETECTION_PROPERTIES_EXT"/> + + </require> + </extension> + + <extension name="XR_ACER_extension_431" number="431" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_431_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_431"" name="XR_ACER_EXTENSION_431_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_432" number="432" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_432_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_432"" name="XR_ACER_EXTENSION_432_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_433" number="433" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_433_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_433"" name="XR_ACER_EXTENSION_433_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_434" number="434" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_434_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_434"" name="XR_ACER_EXTENSION_434_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_435" number="435" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_435_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_435"" name="XR_ACER_EXTENSION_435_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_436" number="436" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_436_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_436"" name="XR_ACER_EXTENSION_436_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_437" number="437" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_437_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_437"" name="XR_ACER_EXTENSION_437_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_438" number="438" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_438_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_438"" name="XR_ACER_EXTENSION_438_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_439" number="439" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_439_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_439"" name="XR_ACER_EXTENSION_439_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_440" number="440" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_440_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_440"" name="XR_ACER_EXTENSION_440_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_441" number="441" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_441_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_441"" name="XR_ACER_EXTENSION_441_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_442" number="442" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_442_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_442"" name="XR_ACER_EXTENSION_442_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ACER_extension_443" number="443" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ACER_extension_443_SPEC_VERSION"/> + <enum value=""XR_ACER_extension_443"" name="XR_ACER_EXTENSION_443_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_444" number="444" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_444_SPEC_VERSION"/> + <enum value=""XR_MND_extension_444"" name="XR_MND_EXTENSION_444_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MNDX_xdev_space" number="445" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MNDX_xdev_space_SPEC_VERSION"/> + <enum value=""XR_MNDX_xdev_space"" name="XR_MNDX_XDEV_SPACE_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_446" number="446" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_446_SPEC_VERSION"/> + <enum value=""XR_MND_extension_446"" name="XR_MND_EXTENSION_446_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_447" number="447" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_447_SPEC_VERSION"/> + <enum value=""XR_MND_extension_447"" name="XR_MND_EXTENSION_447_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_448" number="448" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_448_SPEC_VERSION"/> + <enum value=""XR_MND_extension_448"" name="XR_MND_EXTENSION_448_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_449" number="449" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_449_SPEC_VERSION"/> + <enum value=""XR_MND_extension_449"" name="XR_MND_EXTENSION_449_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_450" number="450" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_450_SPEC_VERSION"/> + <enum value=""XR_MND_extension_450"" name="XR_MND_EXTENSION_450_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_451" number="451" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_451_SPEC_VERSION"/> + <enum value=""XR_MND_extension_451"" name="XR_MND_EXTENSION_451_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_452" number="452" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_452_SPEC_VERSION"/> + <enum value=""XR_MND_extension_452"" name="XR_MND_EXTENSION_452_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_MND_extension_453" number="453" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_MND_extension_453_SPEC_VERSION"/> + <enum value=""XR_MND_extension_453"" name="XR_MND_EXTENSION_453_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_OPPO_controller_interaction" number="454" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_OPPO_controller_interaction_SPEC_VERSION"/> + <enum value=""XR_OPPO_controller_interaction"" name="XR_OPPO_CONTROLLER_INTERACTION_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/oppo/mr_controller_oppo"/> + </require> + + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/oppo/mr_controller_oppo"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/oppo/mr_controller_oppo"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/oppo/mr_controller_oppo"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_ANDROID_extension_455" number="455" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_455_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_455"" name="XR_ANDROID_EXTENSION_455_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_trackables" number="456" type="instance" supported="openxr" deprecatedby="XR_EXT_spatial_entity+XR_EXT_spatial_plane_tracking+XR_ANDROID_spatial_component_subsumed_by+XR_EXT_spatial_anchor+XR_ANDROID_spatial_entity_bound_anchor+XR_ANDROID_spatial_anchor_space"> + <require> + <enum value="2" name="XR_ANDROID_trackables_SPEC_VERSION"/> + <enum value=""XR_ANDROID_trackables"" name="XR_ANDROID_TRACKABLES_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_TRACKABLE_GET_INFO_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_ANCHOR_SPACE_CREATE_INFO_ANDROID"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_TRACKABLE_PLANE_ANDROID"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_TRACKABLE_TRACKER_CREATE_INFO_ANDROID"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_SYSTEM_TRACKABLES_PROPERTIES_ANDROID"/> + + <enum offset="1" extends="XrObjectType" name="XR_OBJECT_TYPE_TRACKABLE_TRACKER_ANDROID" comment="XrTrackableTrackerANDROID"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_MISMATCHING_TRACKABLE_TYPE_ANDROID" comment="Indicates that the parameters contains multiple trackable types."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_TRACKABLE_TYPE_NOT_SUPPORTED_ANDROID" comment="Indicates that the function is not supported by the given trackable type."/> + + <type name="XR_NULL_TRACKABLE_ANDROID"/> + <type name="XrTrackableANDROID"/> + <type name="XrTrackableTrackerANDROID"/> + <type name="XrTrackingStateANDROID"/> + <type name="XrTrackableTypeANDROID"/> + <type name="XrPlaneTypeANDROID"/> + <type name="XrPlaneLabelANDROID"/> + <type name="XrTrackableTrackerCreateInfoANDROID"/> + <type name="XrTrackableGetInfoANDROID"/> + <type name="XrTrackablePlaneANDROID"/> + <type name="XrAnchorSpaceCreateInfoANDROID"/> + <type name="XrSystemTrackablesPropertiesANDROID"/> + + <command name="xrEnumerateSupportedTrackableTypesANDROID"/> + <command name="xrEnumerateSupportedAnchorTrackableTypesANDROID"/> + <command name="xrCreateTrackableTrackerANDROID"/> + <command name="xrDestroyTrackableTrackerANDROID"/> + <command name="xrGetAllTrackablesANDROID"/> + <command name="xrGetTrackablePlaneANDROID"/> + <command name="xrCreateAnchorSpaceANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_eye_tracking" number="457" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ANDROID_eye_tracking_SPEC_VERSION"/> + <enum value=""XR_ANDROID_eye_tracking"" name="XR_ANDROID_EYE_TRACKING_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_EYES_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_EYE_TRACKER_CREATE_INFO_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_EYES_GET_INFO_ANDROID"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SYSTEM_EYE_TRACKING_PROPERTIES_ANDROID"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_EYE_TRACKER_ANDROID" comment="XrEyeTrackerANDROID"/> + + <enum value="2" name="XR_EYE_MAX_ANDROID"/> + + <type name="XrSystemEyeTrackingPropertiesANDROID"/> + <type name="XrEyeTrackerANDROID"/> + <type name="XrEyeIndexANDROID"/> + <type name="XrEyeStateANDROID"/> + <type name="XrEyeTrackingModeANDROID"/> + <type name="XrEyeANDROID"/> + <type name="XrEyesANDROID"/> + <type name="XrEyesGetInfoANDROID"/> + <type name="XrEyeTrackerCreateInfoANDROID"/> + + <command name="xrCreateEyeTrackerANDROID"/> + <command name="xrDestroyEyeTrackerANDROID"/> + <command name="xrGetFineTrackingEyesInfoANDROID"/> + <command name="xrGetCoarseTrackingEyesInfoANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_device_anchor_persistence" number="458" type="instance" depends="XR_EXT_uuid+XR_ANDROID_trackables" supported="openxr" deprecatedby="XR_EXT_spatial_persistence+XR_EXT_spatial_persistence_operations"> + <require> + <enum value="1" name="XR_ANDROID_device_anchor_persistence_SPEC_VERSION"/> + <enum value=""XR_ANDROID_device_anchor_persistence"" name="XR_ANDROID_DEVICE_ANCHOR_PERSISTENCE_EXTENSION_NAME"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_PERSISTED_ANCHOR_SPACE_CREATE_INFO_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_PERSISTED_ANCHOR_SPACE_INFO_ANDROID"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_DEVICE_ANCHOR_PERSISTENCE_CREATE_INFO_ANDROID"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SYSTEM_DEVICE_ANCHOR_PERSISTENCE_PROPERTIES_ANDROID"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_ANCHOR_ID_NOT_FOUND_ANDROID" comment="XrUuidExt passed to the function was not found to be a persisted anchor."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_ANCHOR_ALREADY_PERSISTED_ANDROID" comment="XrUuidExt passed to the function was already marked to be persisted."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_ANCHOR_NOT_TRACKING_ANDROID" comment="ANchor cannot be persisted because it is not tracking."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_PERSISTED_DATA_NOT_READY_ANDROID" comment="Persisted data stored by this app has not been loaded yet."/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_DEVICE_ANCHOR_PERSISTENCE_ANDROID" comment="XrDeviceAnchorPersistenceANDROID"/> + + <type name="XrDeviceAnchorPersistenceANDROID"/> + <type name="XrDeviceAnchorPersistenceCreateInfoANDROID"/> + <type name="XrPersistedAnchorSpaceCreateInfoANDROID"/> + <type name="XrPersistedAnchorSpaceInfoANDROID"/> + <type name="XrAnchorPersistStateANDROID"/> + <type name="XrSystemDeviceAnchorPersistencePropertiesANDROID"/> + + <command name="xrEnumerateSupportedPersistenceAnchorTypesANDROID"/> + <command name="xrCreateDeviceAnchorPersistenceANDROID"/> + <command name="xrDestroyDeviceAnchorPersistenceANDROID"/> + <command name="xrPersistAnchorANDROID"/> + <command name="xrGetAnchorPersistStateANDROID"/> + <command name="xrCreatePersistedAnchorSpaceANDROID"/> + <command name="xrEnumeratePersistedAnchorsANDROID"/> + <command name="xrUnpersistAnchorANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_face_tracking" number="459" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ANDROID_face_tracking_SPEC_VERSION"/> + <enum value=""XR_ANDROID_face_tracking"" name="XR_ANDROID_FACE_TRACKING_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_FACE_TRACKER_CREATE_INFO_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_FACE_STATE_GET_INFO_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_FACE_STATE_ANDROID"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SYSTEM_FACE_TRACKING_PROPERTIES_ANDROID"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SERVICE_NOT_READY_ANDROID" comment="The underlying tracking service is not yet ready."/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_FACE_TRACKER_ANDROID" comment="XrFaceTrackerANDROID"/> + + <enum value="68" name="XR_FACE_PARAMETER_COUNT_ANDROID"/> + <enum value="3" name="XR_FACE_REGION_CONFIDENCE_COUNT_ANDROID"/> + + <type name="XrFaceTrackerANDROID"/> + <type name="XrFaceParameterIndicesANDROID"/> + <type name="XrFaceTrackingStateANDROID"/> + <type name="XrFaceConfidenceRegionsANDROID"/> + <type name="XrFaceTrackerCreateInfoANDROID"/> + <type name="XrFaceStateGetInfoANDROID"/> + <type name="XrFaceStateANDROID"/> + <type name="XrSystemFaceTrackingPropertiesANDROID"/> + + <command name="xrCreateFaceTrackerANDROID"/> + <command name="xrDestroyFaceTrackerANDROID"/> + <command name="xrGetFaceStateANDROID"/> + <command name="xrGetFaceCalibrationStateANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_460" number="460" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_460_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_460"" name="XR_ANDROID_extension_460_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_passthrough_camera_state" number="461" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ANDROID_passthrough_camera_state_SPEC_VERSION"/> + <enum value=""XR_ANDROID_passthrough_camera_state"" name="XR_ANDROID_PASSTHROUGH_CAMERA_STATE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_CAMERA_STATE_GET_INFO_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SYSTEM_PASSTHROUGH_CAMERA_STATE_PROPERTIES_ANDROID"/> + + <type name="XrSystemPassthroughCameraStatePropertiesANDROID"/> + <type name="XrPassthroughCameraStateANDROID"/> + <type name="XrPassthroughCameraStateGetInfoANDROID"/> + + <command name="xrGetPassthroughCameraStateANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_recommended_resolution" number="462" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ANDROID_recommended_resolution_SPEC_VERSION"/> + <enum value=""XR_ANDROID_recommended_resolution"" name="XR_ANDROID_RECOMMENDED_RESOLUTION_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_RECOMMENDED_RESOLUTION_CHANGED_ANDROID"/> + <type name="XrEventDataRecommendedResolutionChangedANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_composition_layer_passthrough_mesh" number="463" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ANDROID_composition_layer_passthrough_mesh_SPEC_VERSION"/> + <enum value=""XR_ANDROID_composition_layer_passthrough_mesh"" name="XR_ANDROID_COMPOSITION_LAYER_PASSTHROUGH_MESH_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_LAYER_CREATE_INFO_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_PASSTHROUGH_LAYER_MESH_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_COMPOSITION_LAYER_PASSTHROUGH_ANDROID"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SYSTEM_PASSTHROUGH_LAYER_PROPERTIES_ANDROID"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_MESH_DATA_LIMIT_EXCEEDED_ANDROID" comment="Returned by passthrough layer functions to indicate the mesh data exceeds the supported limit."/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_PASSTHROUGH_LAYER_ANDROID" comment="XrPassthroughLayerANDROID"/> + + <type name="XrPassthroughLayerANDROID"/> + <type name="XrWindingOrderANDROID"/> + <type name="XrPassthroughLayerCreateInfoANDROID"/> + <type name="XrPassthroughLayerMeshANDROID"/> + <type name="XrCompositionLayerPassthroughANDROID"/> + <type name="XrSystemPassthroughLayerPropertiesANDROID"/> + + <command name="xrCreatePassthroughLayerANDROID"/> + <command name="xrDestroyPassthroughLayerANDROID"/> + <command name="xrSetPassthroughLayerMeshANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_raycast" number="464" type="instance" supported="openxr" depends="XR_ANDROID_trackables" deprecatedby="XR_ANDROID_spatial_discovery_raycast"> + <require> + <enum value="1" name="XR_ANDROID_raycast_SPEC_VERSION"/> + <enum value=""XR_ANDROID_raycast"" name="XR_ANDROID_RAYCAST_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_RAYCAST_INFO_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_RAYCAST_HIT_RESULTS_ANDROID"/> + + <enum offset="0" extends="XrTrackableTypeANDROID" name="XR_TRACKABLE_TYPE_DEPTH_ANDROID" comment="Indicates that the trackable is the perception depth buffer."/> + + <type name="XrRaycastInfoANDROID"/> + <type name="XrRaycastHitResultANDROID"/> + <type name="XrRaycastHitResultsANDROID"/> + + <command name="xrEnumerateRaycastSupportedTrackableTypesANDROID"/> + <command name="xrRaycastANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_465" number="465" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_465_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_465"" name="XR_ANDROID_extension_465_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_performance_metrics" number="466" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ANDROID_performance_metrics_SPEC_VERSION"/> + <enum value=""XR_ANDROID_performance_metrics"" name="XR_ANDROID_PERFORMANCE_METRICS_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_PERFORMANCE_METRICS_STATE_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_PERFORMANCE_METRICS_COUNTER_ANDROID"/> + + <type name="XrPerformanceMetricsCounterUnitANDROID"/> + <type name="XrPerformanceMetricsCounterFlagsANDROID"/> + <type name="XrPerformanceMetricsStateANDROID"/> + <type name="XrPerformanceMetricsCounterANDROID"/> + <type name="XrPerformanceMetricsCounterFlagBitsANDROID"/> + + <command name="xrEnumeratePerformanceMetricsCounterPathsANDROID"/> + <command name="xrSetPerformanceMetricsStateANDROID"/> + <command name="xrGetPerformanceMetricsStateANDROID"/> + <command name="xrQueryPerformanceMetricsCounterANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_trackables_object" number="467" type="instance" supported="openxr" depends="XR_ANDROID_trackables" deprecatedby="XR_ANDROID_spatial_object_tracking"> + <require> + <enum value="2" name="XR_ANDROID_trackables_object_SPEC_VERSION"/> + <enum value=""XR_ANDROID_trackables_object"" name="XR_ANDROID_TRACKABLES_OBJECT_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_TRACKABLE_OBJECT_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_TRACKABLE_OBJECT_CONFIGURATION_ANDROID"/> + <enum offset="0" extends="XrTrackableTypeANDROID" name="XR_TRACKABLE_TYPE_OBJECT_ANDROID" comment="Indicates that the trackable is the object."/> + + <type name="XrObjectLabelANDROID"/> + <type name="XrTrackableObjectANDROID"/> + <type name="XrTrackableObjectConfigurationANDROID"/> + + <command name="xrGetTrackableObjectANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_unbounded_reference_space" number="468" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ANDROID_unbounded_reference_space_SPEC_VERSION"/> + <enum value=""XR_ANDROID_unbounded_reference_space"" name="XR_ANDROID_UNBOUNDED_REFERENCE_SPACE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrReferenceSpaceType" name="XR_REFERENCE_SPACE_TYPE_UNBOUNDED_ANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_469" number="469" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_469_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_469"" name="XR_ANDROID_extension_469_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_future" number="470" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="2" name="XR_EXT_future_SPEC_VERSION"/> + <enum value=""XR_EXT_future"" name="XR_EXT_FUTURE_EXTENSION_NAME"/> + + <enum value="0" name="XR_NULL_FUTURE_EXT"/> + + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_FUTURE_PENDING_EXT" comment="Returned by completion function to indicate future is not ready."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_FUTURE_INVALID_EXT" comment="Returned by completion function to indicate future is not valid."/> + + <type name="XrFutureEXT"/> + <type name="XrFutureStateEXT"/> + + <type name="XrFutureCancelInfoEXT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_FUTURE_CANCEL_INFO_EXT"/> + + <type name="XrFuturePollInfoEXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_FUTURE_POLL_INFO_EXT"/> + + <type name="XrFutureCompletionBaseHeaderEXT"/> + <type name="XrFutureCompletionEXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_FUTURE_COMPLETION_EXT"/> + + <type name="XrFuturePollResultEXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_FUTURE_POLL_RESULT_EXT"/> + + + <command name="xrPollFutureEXT"/> + <command name="xrCancelFutureEXT"/> + + </require> + </extension> + + <extension name="XR_EXT_user_presence" number="471" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_EXT_user_presence_SPEC_VERSION"/> + <enum value=""XR_EXT_user_presence"" name="XR_EXT_USER_PRESENCE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_USER_PRESENCE_CHANGED_EXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SYSTEM_USER_PRESENCE_PROPERTIES_EXT"/> + + <type name="XrEventDataUserPresenceChangedEXT"/> + <type name="XrSystemUserPresencePropertiesEXT"/> + </require> + </extension> + + <extension name="XR_KHR_locate_spaces" number="472" type="instance" supported="openxr" promotedto="XR_VERSION_1_1" ratified="openxr"> + <require> + <enum value="1" name="XR_KHR_locate_spaces_SPEC_VERSION"/> + <enum value=""XR_KHR_locate_spaces"" name="XR_KHR_LOCATE_SPACES_EXTENSION_NAME"/> + <enum extends="XrStructureType" name="XR_TYPE_SPACES_LOCATE_INFO_KHR" alias="XR_TYPE_SPACES_LOCATE_INFO"/> + <enum extends="XrStructureType" name="XR_TYPE_SPACE_LOCATIONS_KHR" alias="XR_TYPE_SPACE_LOCATIONS"/> + <enum extends="XrStructureType" name="XR_TYPE_SPACE_VELOCITIES_KHR" alias="XR_TYPE_SPACE_VELOCITIES"/> + + <type name="XrSpacesLocateInfoKHR"/> + <type name="XrSpaceLocationDataKHR"/> + <type name="XrSpaceLocationsKHR"/> + <type name="XrSpaceVelocityDataKHR"/> + <type name="XrSpaceVelocitiesKHR"/> + + <command name="xrLocateSpacesKHR"/> + </require> + </extension> + + <extension name="XR_ML_system_notifications" number="474" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ML_system_notifications_SPEC_VERSION"/> + <enum value=""XR_ML_system_notifications"" name="XR_ML_SYSTEM_NOTIFICATIONS_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_NOTIFICATIONS_SET_INFO_ML"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SYSTEM_NOTIFICATION_PERMISSION_DENIED_ML" comment="The com.magicleap.permission.SYSTEM_NOTIFICATION permission was not granted."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SYSTEM_NOTIFICATION_INCOMPATIBLE_SKU_ML" comment="Incompatible SKU detected."/> + + <type name="XrSystemNotificationsSetInfoML"/> + + <command name="xrSetSystemNotificationsML"/> + </require> + </extension> + + <extension name="XR_ML_world_mesh_detection" number="475" type="instance" depends="XR_EXT_future" supported="openxr"> + <require> + <enum value="1" name="XR_ML_world_mesh_detection_SPEC_VERSION"/> + <enum value=""XR_ML_world_mesh_detection"" name="XR_ML_WORLD_MESH_DETECTION_EXTENSION_NAME"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_WORLD_MESH_DETECTOR_ML" comment="XrWorldMeshDetectorML"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_WORLD_MESH_DETECTOR_PERMISSION_DENIED_ML" comment="The world mesh detector permission was not granted."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_WORLD_MESH_DETECTOR_SPACE_NOT_LOCATABLE_ML" comment="At the time of the call the runtime was unable to locate the space and cannot fulfill your request."/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_DETECTOR_CREATE_INFO_ML"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_STATE_REQUEST_INFO_ML"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_BLOCK_STATE_ML"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_STATE_REQUEST_COMPLETION_ML"/> + + <enum offset="5" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_BUFFER_RECOMMENDED_SIZE_INFO_ML"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_BUFFER_SIZE_ML"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_BUFFER_ML"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_BLOCK_REQUEST_ML"/> + <enum offset="9" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_GET_INFO_ML"/> + <enum offset="10" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_BLOCK_ML"/> + <enum offset="11" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_REQUEST_COMPLETION_ML"/> + <enum offset="12" extends="XrStructureType" name="XR_TYPE_WORLD_MESH_REQUEST_COMPLETION_INFO_ML"/> + + + <type name="XrWorldMeshDetectorML"/> + + <type name="XrWorldMeshDetectorFlagsML"/> + <type name="XrWorldMeshDetectorFlagBitsML"/> + <type name="XrWorldMeshDetectorLodML"/> + <type name="XrWorldMeshBlockStatusML"/> + <type name="XrWorldMeshBlockResultML"/> + + <type name="XrWorldMeshDetectorCreateInfoML"/> + <type name="XrWorldMeshBlockStateML"/> + <type name="XrWorldMeshStateRequestInfoML"/> + <type name="XrWorldMeshStateRequestCompletionML"/> + + <type name="XrWorldMeshBufferRecommendedSizeInfoML"/> + <type name="XrWorldMeshBufferSizeML"/> + <type name="XrWorldMeshBufferML"/> + <type name="XrWorldMeshBlockRequestML"/> + <type name="XrWorldMeshGetInfoML"/> + <type name="XrWorldMeshBlockML"/> + <type name="XrWorldMeshRequestCompletionInfoML"/> + <type name="XrWorldMeshRequestCompletionML"/> + + <command name="xrCreateWorldMeshDetectorML"/> + <command name="xrDestroyWorldMeshDetectorML"/> + <command name="xrRequestWorldMeshStateAsyncML"/> + <command name="xrRequestWorldMeshStateCompleteML"/> + <command name="xrGetWorldMeshBufferRecommendSizeML"/> + <command name="xrAllocateWorldMeshBufferML"/> + <command name="xrFreeWorldMeshBufferML"/> + <command name="xrRequestWorldMeshAsyncML"/> + <command name="xrRequestWorldMeshCompleteML"/> + + </require> + </extension> + + <extension name="XR_ML_extension_476" number="476" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_476_SPEC_VERSION"/> + <enum value=""XR_ML_extension_476"" name="XR_ML_extension_476_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_477" number="477" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_477_SPEC_VERSION"/> + <enum value=""XR_ML_extension_477"" name="XR_ML_extension_477_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_478" number="478" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_478_SPEC_VERSION"/> + <enum value=""XR_ML_extension_478"" name="XR_ML_extension_478_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_479" number="479" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_479_SPEC_VERSION"/> + <enum value=""XR_ML_extension_479"" name="XR_ML_extension_479_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_480" number="480" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_480_SPEC_VERSION"/> + <enum value=""XR_ML_extension_480"" name="XR_ML_extension_480_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_481" number="481" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_481_SPEC_VERSION"/> + <enum value=""XR_ML_extension_481"" name="XR_ML_extension_481_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_482" number="482" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_482_SPEC_VERSION"/> + <enum value=""XR_ML_extension_482"" name="XR_ML_extension_482_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_facial_expression" number="483" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ML_facial_expression_SPEC_VERSION"/> + <enum value=""XR_ML_facial_expression"" name="XR_ML_FACIAL_EXPRESSION_EXTENSION_NAME"/> + + <enum offset="0" extends="XrResult" name="XR_ERROR_FACIAL_EXPRESSION_PERMISSION_DENIED_ML" comment="Permission to track facial expressions was not granted"/> + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_FACIAL_EXPRESSION_CLIENT_ML" comment="XrFacialExpressionClientML"/> + + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SYSTEM_FACIAL_EXPRESSION_PROPERTIES_ML"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_FACIAL_EXPRESSION_CLIENT_CREATE_INFO_ML"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_FACIAL_EXPRESSION_BLEND_SHAPE_GET_INFO_ML"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_FACIAL_EXPRESSION_BLEND_SHAPE_PROPERTIES_ML"/> + + <type name="XrFacialExpressionClientML"/> + + <type name="XrFacialBlendShapeML"/> + <type name="XrSystemFacialExpressionPropertiesML"/> + <type name="XrFacialExpressionClientCreateInfoML"/> + <type name="XrFacialExpressionBlendShapeGetInfoML"/> + <type name="XrFacialExpressionBlendShapePropertiesML"/> + <type name="XrFacialExpressionBlendShapePropertiesFlagsML"/> + <type name="XrFacialExpressionBlendShapePropertiesFlagBitsML"/> + + <command name="xrCreateFacialExpressionClientML"/> + <command name="xrDestroyFacialExpressionClientML"/> + <command name="xrGetFacialExpressionBlendShapePropertiesML"/> + </require> + </extension> + + <extension name="XR_ML_view_configuration_depth_range_change" number="484" depends="XR_EXT_view_configuration_depth_range" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ML_view_configuration_depth_range_change_SPEC_VERSION"/> + <enum value=""XR_ML_view_configuration_depth_range_change"" name="XR_ML_VIEW_CONFIGURATION_DEPTH_RANGE_CHANGE_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_485" number="485" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_485_SPEC_VERSION"/> + <enum value=""XR_ML_extension_485"" name="XR_ML_extension_485_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_486" number="486" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_486_SPEC_VERSION"/> + <enum value=""XR_ML_extension_486"" name="XR_ML_extension_486_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_487" number="487" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_487_SPEC_VERSION"/> + <enum value=""XR_ML_extension_487"" name="XR_ML_extension_487_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_488" number="488" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_488_SPEC_VERSION"/> + <enum value=""XR_ML_extension_488"" name="XR_ML_extension_488_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_489" number="489" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_489_SPEC_VERSION"/> + <enum value=""XR_ML_extension_489"" name="XR_ML_extension_489_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_490" number="490" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_490_SPEC_VERSION"/> + <enum value=""XR_ML_extension_490"" name="XR_ML_extension_490_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_491" number="491" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_491_SPEC_VERSION"/> + <enum value=""XR_ML_extension_491"" name="XR_ML_extension_491_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_492" number="492" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_492_SPEC_VERSION"/> + <enum value=""XR_ML_extension_492"" name="XR_ML_extension_492_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_493" number="493" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_493_SPEC_VERSION"/> + <enum value=""XR_ML_extension_493"" name="XR_ML_extension_493_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_494" number="494" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_494_SPEC_VERSION"/> + <enum value=""XR_ML_extension_494"" name="XR_ML_extension_494_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_495" number="495" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_495_SPEC_VERSION"/> + <enum value=""XR_ML_extension_495"" name="XR_ML_extension_495_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_496" number="496" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_496_SPEC_VERSION"/> + <enum value=""XR_ML_extension_496"" name="XR_ML_extension_496_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ML_extension_497" number="497" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ML_extension_497_SPEC_VERSION"/> + <enum value=""XR_ML_extension_497"" name="XR_ML_extension_497_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_controller_interaction" number="498" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_YVR_controller_interaction_SPEC_VERSION"/> + <enum value=""XR_YVR_controller_interaction"" name="XR_YVR_CONTROLLER_INTERACTION_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/yvr/touch_controller_yvr"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/yvr/touch_controller_yvr"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/yvr/touch_controller_yvr"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/yvr/touch_controller_yvr"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_YVR_extension_499" number="499" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_499_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_499"" name="XR_YVR_extension_499_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_500" number="500" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_500_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_500"" name="XR_YVR_extension_500_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_501" number="501" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_501_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_501"" name="XR_YVR_extension_501_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_502" number="502" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_502_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_502"" name="XR_YVR_extension_502_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_503" number="503" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_503_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_503"" name="XR_YVR_extension_503_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_504" number="504" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_504_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_504"" name="XR_YVR_extension_504_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_505" number="505" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_505_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_505"" name="XR_YVR_extension_505_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_506" number="506" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_506_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_506"" name="XR_YVR_extension_506_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_507" number="507" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_507_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_507"" name="XR_YVR_extension_507_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_508" number="508" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_508_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_508"" name="XR_YVR_extension_508_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_509" number="509" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_509_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_509"" name="XR_YVR_extension_509_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_510" number="510" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_510_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_510"" name="XR_YVR_extension_510_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_511" number="511" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_511_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_511"" name="XR_YVR_extension_511_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_512" number="512" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_512_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_512"" name="XR_YVR_extension_512_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_513" number="513" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_513_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_513"" name="XR_YVR_extension_513_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_514" number="514" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_514_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_514"" name="XR_YVR_extension_514_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_515" number="515" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_515_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_515"" name="XR_YVR_extension_515_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_516" number="516" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_516_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_516"" name="XR_YVR_extension_516_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_517" number="517" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_517_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_517"" name="XR_YVR_extension_517_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_518" number="518" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_518_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_518"" name="XR_YVR_extension_518_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_519" number="519" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_519_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_519"" name="XR_YVR_extension_519_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_520" number="520" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_520_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_520"" name="XR_YVR_extension_520_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_521" number="521" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_521_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_521"" name="XR_YVR_extension_521_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_522" number="522" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_522_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_522"" name="XR_YVR_extension_522_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_YVR_extension_523" number="523" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_YVR_extension_523_SPEC_VERSION"/> + <enum value=""XR_YVR_extension_523"" name="XR_YVR_extension_523_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_524" number="524" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_524_SPEC_VERSION"/> + <enum value=""XR_NV_extension_524"" name="XR_NV_extension_524_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_525" number="525" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_525_SPEC_VERSION"/> + <enum value=""XR_NV_extension_525"" name="XR_NV_extension_525_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_526" number="526" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_526_SPEC_VERSION"/> + <enum value=""XR_NV_extension_526"" name="XR_NV_extension_526_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_527" number="527" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_527_SPEC_VERSION"/> + <enum value=""XR_NV_extension_527"" name="XR_NV_extension_527_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_528" number="528" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_528_SPEC_VERSION"/> + <enum value=""XR_NV_extension_528"" name="XR_NV_extension_528_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_boundary_visibility" number="529" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_boundary_visibility_SPEC_VERSION"/> + <enum value=""XR_META_boundary_visibility"" name="XR_META_BOUNDARY_VISIBILITY_EXTENSION_NAME"/> + + <enum offset="0" extends="XrResult" name="XR_BOUNDARY_VISIBILITY_SUPPRESSION_NOT_ALLOWED_META" comment="Runtime did not accept the request to suppress the boundary visibility"/> + + <type name="XrSystemBoundaryVisibilityPropertiesMETA"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_BOUNDARY_VISIBILITY_PROPERTIES_META"/> + <type name="XrEventDataBoundaryVisibilityChangedMETA"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_BOUNDARY_VISIBILITY_CHANGED_META"/> + + <type name="XrBoundaryVisibilityMETA"/> + + <command name="xrRequestBoundaryVisibilityMETA"/> + </require> + </extension> + + <extension name="XR_META_extension_530" number="530" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_530_SPEC_VERSION"/> + <enum value=""XR_META_extension_530"" name="XR_META_extension_530_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_531" number="531" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_531_SPEC_VERSION"/> + <enum value=""XR_META_extension_531"" name="XR_META_extension_531_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_532" number="532" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_532_SPEC_VERSION"/> + <enum value=""XR_META_extension_532"" name="XR_META_extension_532_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_simultaneous_hands_and_controllers" number="533" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_simultaneous_hands_and_controllers_SPEC_VERSION"/> + <enum value=""XR_META_simultaneous_hands_and_controllers"" name="XR_META_SIMULTANEOUS_HANDS_AND_CONTROLLERS_EXTENSION_NAME"/> + + <type name="XrSystemSimultaneousHandsAndControllersPropertiesMETA"/> + <type name="XrSimultaneousHandsAndControllersTrackingResumeInfoMETA"/> + <type name="XrSimultaneousHandsAndControllersTrackingPauseInfoMETA"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SYSTEM_SIMULTANEOUS_HANDS_AND_CONTROLLERS_PROPERTIES_META"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SIMULTANEOUS_HANDS_AND_CONTROLLERS_TRACKING_RESUME_INFO_META"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SIMULTANEOUS_HANDS_AND_CONTROLLERS_TRACKING_PAUSE_INFO_META"/> + + <command name="xrResumeSimultaneousHandsAndControllersTrackingMETA"/> + <command name="xrPauseSimultaneousHandsAndControllersTrackingMETA"/> + </require> + </extension> + + <extension name="XR_META_extension_534" number="534" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_534_SPEC_VERSION"/> + <enum value=""XR_META_extension_534"" name="XR_META_extension_534_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_535" number="535" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_535_SPEC_VERSION"/> + <enum value=""XR_META_extension_535"" name="XR_META_extension_535_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_536" number="536" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_536_SPEC_VERSION"/> + <enum value=""XR_META_extension_536"" name="XR_META_extension_536_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_537" number="537" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_537_SPEC_VERSION"/> + <enum value=""XR_META_extension_537"" name="XR_META_extension_537_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_538" number="538" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_538_SPEC_VERSION"/> + <enum value=""XR_META_extension_538"" name="XR_META_extension_538_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_539" number="539" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_539_SPEC_VERSION"/> + <enum value=""XR_META_extension_539"" name="XR_META_extension_539_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_540" number="540" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_540_SPEC_VERSION"/> + <enum value=""XR_META_extension_540"" name="XR_META_extension_540_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_541" number="541" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_541_SPEC_VERSION"/> + <enum value=""XR_META_extension_541"" name="XR_META_extension_541_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_face_tracking_visemes" number="542" type="instance" supported="openxr" depends="XR_VERSION_1_0+XR_FB_face_tracking2"> + <require> + <enum value="1" name="XR_META_face_tracking_visemes_SPEC_VERSION"/> + <enum value=""XR_META_face_tracking_visemes"" name="XR_META_FACE_TRACKING_VISEMES_EXTENSION_NAME"/> + + <type name="XrFaceTrackingVisemeMETA"/> + + <enum value="15" name="XR_FACE_TRACKING_VISEME_COUNT_META"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_FACE_TRACKING_VISEMES_META"/> + <type name="XrFaceTrackingVisemesMETA"/> + + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SYSTEM_FACE_TRACKING_VISEMES_PROPERTIES_META"/> + <type name="XrSystemFaceTrackingVisemesPropertiesMETA"/> + </require> + </extension> + + <extension name="XR_META_extension_543" number="543" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_543_SPEC_VERSION"/> + <enum value=""XR_META_extension_543"" name="XR_META_extension_543_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_544" number="544" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_544_SPEC_VERSION"/> + <enum value=""XR_META_extension_544"" name="XR_META_extension_544_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_545" number="545" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_545_SPEC_VERSION"/> + <enum value=""XR_META_extension_545"" name="XR_META_extension_545_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_546" number="546" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_546_SPEC_VERSION"/> + <enum value=""XR_META_extension_546"" name="XR_META_extension_546_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_547" number="547" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_547_SPEC_VERSION"/> + <enum value=""XR_META_extension_547"" name="XR_META_extension_547_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_548" number="548" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_548_SPEC_VERSION"/> + <enum value=""XR_META_extension_548"" name="XR_META_extension_548_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_549" number="549" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_549_SPEC_VERSION"/> + <enum value=""XR_META_extension_549"" name="XR_META_extension_549_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_550" number="550" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_550_SPEC_VERSION"/> + <enum value=""XR_META_extension_550"" name="XR_META_extension_550_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_551" number="551" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_551_SPEC_VERSION"/> + <enum value=""XR_META_extension_551"" name="XR_META_extension_551_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_552" number="552" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_552_SPEC_VERSION"/> + <enum value=""XR_META_extension_552"" name="XR_META_extension_552_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_spatial_entity_semantic_label" number="553" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_spatial_entity_semantic_label_SPEC_VERSION"/> + <enum value=""XR_META_spatial_entity_semantic_label"" name="XR_META_SPATIAL_ENTITY_SEMANTIC_LABEL_EXTENSION_NAME"/> + + <type name="XrSemanticLabelMETA"/> + </require> + </extension> + + <extension name="XR_META_spatial_entity_room_mesh" number="554" type="instance" depends="XR_VERSION_1_0+XR_FB_spatial_entity+XR_META_spatial_entity_semantic_label" supported="openxr"> + <require> + <enum value="1" name="XR_META_spatial_entity_room_mesh_SPEC_VERSION"/> + <enum value=""XR_META_spatial_entity_room_mesh"" name="XR_META_SPATIAL_ENTITY_ROOM_MESH_EXTENSION_NAME"/> + + <enum offset="0" extends="XrSpaceComponentTypeFB" name="XR_SPACE_COMPONENT_TYPE_ROOM_MESH_META" comment="Room mesh component."/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_ROOM_MESH_FACE_INDICES_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPACE_ROOM_MESH_GET_INFO_META"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_ROOM_MESH_META"/> + + <type name="XrRoomMeshFaceMETA"/> + <type name="XrRoomMeshFaceIndicesMETA"/> + <type name="XrSpaceRoomMeshGetInfoMETA"/> + <type name="XrRoomMeshMETA"/> + + <command name="xrGetSpaceRoomMeshMETA"/> + <command name="xrGetSpaceRoomMeshFaceIndicesMETA"/> + </require> + </extension> + + <extension name="XR_EXT_composition_layer_inverted_alpha" number="555" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_EXT_composition_layer_inverted_alpha_SPEC_VERSION"/> + <enum value=""XR_EXT_composition_layer_inverted_alpha"" name="XR_EXT_COMPOSITION_LAYER_INVERTED_ALPHA_EXTENSION_NAME"/> + <enum bitpos="3" extends="XrCompositionLayerFlagBits" name="XR_COMPOSITION_LAYER_INVERTED_ALPHA_BIT_EXT" comment="Indicates that the texture alpha channel stores transparency instead of opacity, and is to be inverted before layer blending."/> + <!-- Addition to core bitmask from EXT approved by WG 14-March-2024 --> + </require> + </extension> + + <extension name="XR_META_extension_556" number="556" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_556_SPEC_VERSION"/> + <enum value=""XR_META_extension_556"" name="XR_META_extension_556_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_557" number="557" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_557_SPEC_VERSION"/> + <enum value=""XR_META_extension_557"" name="XR_META_extension_557_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_558" number="558" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_558_SPEC_VERSION"/> + <enum value=""XR_META_extension_558"" name="XR_META_extension_558_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_559" number="559" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_559_SPEC_VERSION"/> + <enum value=""XR_META_extension_559"" name="XR_META_extension_559_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_560" number="560" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_560_SPEC_VERSION"/> + <enum value=""XR_META_extension_560"" name="XR_META_extension_560_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_561" number="561" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_561_SPEC_VERSION"/> + <enum value=""XR_META_extension_561"" name="XR_META_extension_561_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_562" number="562" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_562_SPEC_VERSION"/> + <enum value=""XR_META_extension_562"" name="XR_META_extension_562_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_563" number="563" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_563_SPEC_VERSION"/> + <enum value=""XR_META_extension_563"" name="XR_META_extension_563_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_564" number="564" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_564_SPEC_VERSION"/> + <enum value=""XR_META_extension_564"" name="XR_META_extension_564_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_565" number="565" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_565_SPEC_VERSION"/> + <enum value=""XR_META_extension_565"" name="XR_META_extension_565_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_566" number="566" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_566_SPEC_VERSION"/> + <enum value=""XR_META_extension_566"" name="XR_META_extension_566_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_567" number="567" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_567_SPEC_VERSION"/> + <enum value=""XR_META_extension_567"" name="XR_META_extension_567_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_568" number="568" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_568_SPEC_VERSION"/> + <enum value=""XR_META_extension_568"" name="XR_META_extension_568_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_569" number="569" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_569_SPEC_VERSION"/> + <enum value=""XR_META_extension_569"" name="XR_META_extension_569_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_570" number="570" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_570_SPEC_VERSION"/> + <enum value=""XR_META_extension_570"" name="XR_META_extension_570_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_571" number="571" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_571_SPEC_VERSION"/> + <enum value=""XR_META_extension_571"" name="XR_META_extension_571_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_colocation_discovery" number="572" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_colocation_discovery_SPEC_VERSION"/> + <enum value=""XR_META_colocation_discovery"" name="XR_META_COLOCATION_DISCOVERY_EXTENSION_NAME"/> + + <enum value="1024" name="XR_MAX_COLOCATION_DISCOVERY_BUFFER_SIZE_META"/> + + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_COLOCATION_DISCOVERY_NETWORK_FAILED_META" comment="The network request failed."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_COLOCATION_DISCOVERY_NO_DISCOVERY_METHOD_META" comment="The runtime does not have any methods available to perform discovery."/> + <enum offset="3" extends="XrResult" name="XR_COLOCATION_DISCOVERY_ALREADY_ADVERTISING_META" comment="Colocation advertisement has already been enabled"/> + <enum offset="4" extends="XrResult" name="XR_COLOCATION_DISCOVERY_ALREADY_DISCOVERING_META" comment="Colocation discovery has already been enabled"/> + + <enum offset="10" extends="XrStructureType" name="XR_TYPE_COLOCATION_DISCOVERY_START_INFO_META"/> + <enum offset="11" extends="XrStructureType" name="XR_TYPE_COLOCATION_DISCOVERY_STOP_INFO_META"/> + <enum offset="12" extends="XrStructureType" name="XR_TYPE_COLOCATION_ADVERTISEMENT_START_INFO_META"/> + <enum offset="13" extends="XrStructureType" name="XR_TYPE_COLOCATION_ADVERTISEMENT_STOP_INFO_META"/> + <enum offset="20" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_START_COLOCATION_ADVERTISEMENT_COMPLETE_META"/> + <enum offset="21" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_STOP_COLOCATION_ADVERTISEMENT_COMPLETE_META"/> + <enum offset="22" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_COLOCATION_ADVERTISEMENT_COMPLETE_META"/> + <enum offset="23" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_START_COLOCATION_DISCOVERY_COMPLETE_META"/> + <enum offset="24" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_COLOCATION_DISCOVERY_RESULT_META"/> + <enum offset="25" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_COLOCATION_DISCOVERY_COMPLETE_META"/> + <enum offset="26" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_STOP_COLOCATION_DISCOVERY_COMPLETE_META"/> + <enum offset="30" extends="XrStructureType" name="XR_TYPE_SYSTEM_COLOCATION_DISCOVERY_PROPERTIES_META"/> + + <type name="XrColocationDiscoveryStartInfoMETA"/> + <type name="XrColocationDiscoveryStopInfoMETA"/> + <type name="XrColocationAdvertisementStartInfoMETA"/> + <type name="XrColocationAdvertisementStopInfoMETA"/> + + <type name="XrEventDataStartColocationAdvertisementCompleteMETA"/> + <type name="XrEventDataStopColocationAdvertisementCompleteMETA"/> + <type name="XrEventDataColocationAdvertisementCompleteMETA"/> + <type name="XrEventDataStartColocationDiscoveryCompleteMETA"/> + <type name="XrEventDataColocationDiscoveryResultMETA"/> + <type name="XrEventDataColocationDiscoveryCompleteMETA"/> + <type name="XrEventDataStopColocationDiscoveryCompleteMETA"/> + + <type name="XrSystemColocationDiscoveryPropertiesMETA"/> + + <command name="xrStartColocationDiscoveryMETA"/> + <command name="xrStopColocationDiscoveryMETA"/> + <command name="xrStartColocationAdvertisementMETA"/> + <command name="xrStopColocationAdvertisementMETA"/> + </require> + </extension> + + <extension name="XR_META_spatial_entity_group_sharing" number="573" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_spatial_entity_group_sharing_SPEC_VERSION"/> + <enum value=""XR_META_spatial_entity_group_sharing"" name="XR_META_SPATIAL_ENTITY_GROUP_SHARING_EXTENSION_NAME"/> + + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_SPACE_GROUP_NOT_FOUND_META" comment="The group UUID was not found within the runtime"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SHARE_SPACES_RECIPIENT_GROUPS_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPACE_GROUP_UUID_FILTER_INFO_META"/> + <enum offset="100" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPATIAL_ENTITY_GROUP_SHARING_PROPERTIES_META"/> + + <type name="XrSystemSpatialEntityGroupSharingPropertiesMETA"/> + </require> + <require depends="XR_META_spatial_entity_sharing"> + <type name="XrShareSpacesRecipientGroupsMETA"/> + </require> + <require depends="XR_FB_spatial_entity_query"> + <type name="XrSpaceGroupUuidFilterInfoMETA"/> + </require> + </extension> + + <extension name="XR_META_extension_574" number="574" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_574_SPEC_VERSION"/> + <enum value=""XR_META_extension_574"" name="XR_META_extension_574_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_575" number="575" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_575_SPEC_VERSION"/> + <enum value=""XR_META_extension_575"" name="XR_META_extension_575_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_576" number="576" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_576_SPEC_VERSION"/> + <enum value=""XR_META_extension_576"" name="XR_META_extension_576_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_577" number="577" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_577_SPEC_VERSION"/> + <enum value=""XR_META_extension_577"" name="XR_META_extension_577_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_578" number="578" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_578_SPEC_VERSION"/> + <enum value=""XR_META_extension_578"" name="XR_META_extension_578_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_579" number="579" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_579_SPEC_VERSION"/> + <enum value=""XR_META_extension_579"" name="XR_META_extension_579_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_580" number="580" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_580_SPEC_VERSION"/> + <enum value=""XR_META_extension_580"" name="XR_META_extension_580_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_581" number="581" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_581_SPEC_VERSION"/> + <enum value=""XR_META_extension_581"" name="XR_META_extension_581_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_582" number="582" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_582_SPEC_VERSION"/> + <enum value=""XR_META_extension_582"" name="XR_META_extension_582_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_583" number="583" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_583_SPEC_VERSION"/> + <enum value=""XR_META_extension_583"" name="XR_META_extension_583_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_584" number="584" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_584_SPEC_VERSION"/> + <enum value=""XR_META_extension_584"" name="XR_META_extension_584_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_585" number="585" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_585_SPEC_VERSION"/> + <enum value=""XR_META_extension_585"" name="XR_META_extension_585_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_586" number="586" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_586_SPEC_VERSION"/> + <enum value=""XR_META_extension_586"" name="XR_META_extension_586_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_587" number="587" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_587_SPEC_VERSION"/> + <enum value=""XR_META_extension_587"" name="XR_META_extension_587_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_588" number="588" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_588_SPEC_VERSION"/> + <enum value=""XR_META_extension_588"" name="XR_META_extension_588_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_589" number="589" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_589_SPEC_VERSION"/> + <enum value=""XR_META_extension_589"" name="XR_META_extension_589_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_590" number="590" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_590_SPEC_VERSION"/> + <enum value=""XR_META_extension_590"" name="XR_META_extension_590_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_591" number="591" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_591_SPEC_VERSION"/> + <enum value=""XR_META_extension_591"" name="XR_META_extension_591_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_592" number="592" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_592_SPEC_VERSION"/> + <enum value=""XR_META_extension_592"" name="XR_META_extension_592_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_environment_raycast" depends="XR_EXT_future" number="593" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_environment_raycast_SPEC_VERSION"/> + <enum value=""XR_META_environment_raycast"" name="XR_META_ENVIRONMENT_RAYCAST_EXTENSION_NAME"/> + + <type name="XrEnvironmentRaycasterMETA"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_ENVIRONMENT_RAYCASTER_META" comment="XrEnvironmentRaycasterMETA"/> + + <type name="XrSystemEnvironmentRaycastPropertiesMETA"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_ENVIRONMENT_RAYCAST_PROPERTIES_META"/> + + <type name="XrEnvironmentRaycasterCreateInfoMETA"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_RAYCASTER_CREATE_INFO_META"/> + + <type name="XrEnvironmentRaycasterCreateCompletionMETA"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_RAYCASTER_CREATE_COMPLETION_META"/> + + <type name="XrEnvironmentRaycastFilterBaseHeaderMETA"/> + + <type name="XrEnvironmentRaycastHitGetInfoMETA"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_RAYCAST_HIT_GET_INFO_META"/> + + <type name="XrEnvironmentRaycastHitMETA"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_RAYCAST_HIT_META"/> + + <type name="XrEnvironmentRaycastFilterDistanceMETA"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_ENVIRONMENT_RAYCAST_FILTER_DISTANCE_META"/> + + <type name="XrEnvironmentRaycastHitStatusMETA"/> + + <command name="xrCreateEnvironmentRaycasterAsyncMETA"/> + <command name="xrCreateEnvironmentRaycasterCompleteMETA"/> + <command name="xrDestroyEnvironmentRaycasterMETA"/> + <command name="xrPerformEnvironmentRaycastMETA"/> + </require> + </extension> + + <extension name="XR_META_extension_594" number="594" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_594_SPEC_VERSION"/> + <enum value=""XR_META_extension_594"" name="XR_META_extension_594_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_595" number="595" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_595_SPEC_VERSION"/> + <enum value=""XR_META_extension_595"" name="XR_META_extension_595_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_596" number="596" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_596_SPEC_VERSION"/> + <enum value=""XR_META_extension_596"" name="XR_META_extension_596_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_597" number="597" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_597_SPEC_VERSION"/> + <enum value=""XR_META_extension_597"" name="XR_META_extension_597_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_598" number="598" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_598_SPEC_VERSION"/> + <enum value=""XR_META_extension_598"" name="XR_META_extension_598_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_599" number="599" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_599_SPEC_VERSION"/> + <enum value=""XR_META_extension_599"" name="XR_META_extension_599_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_600" number="600" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_600_SPEC_VERSION"/> + <enum value=""XR_META_extension_600"" name="XR_META_extension_600_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_601" number="601" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_601_SPEC_VERSION"/> + <enum value=""XR_META_extension_601"" name="XR_META_extension_601_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_602" number="602" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_602_SPEC_VERSION"/> + <enum value=""XR_META_extension_602"" name="XR_META_extension_602_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_603" number="603" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_603_SPEC_VERSION"/> + <enum value=""XR_META_extension_603"" name="XR_META_extension_603_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_604" number="604" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_604_SPEC_VERSION"/> + <enum value=""XR_META_extension_604"" name="XR_META_extension_604_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_605" number="605" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_605_SPEC_VERSION"/> + <enum value=""XR_META_extension_605"" name="XR_META_extension_605_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_606" number="606" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_606_SPEC_VERSION"/> + <enum value=""XR_META_extension_606"" name="XR_META_extension_606_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_607" number="607" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_607_SPEC_VERSION"/> + <enum value=""XR_META_extension_607"" name="XR_META_extension_607_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_608" number="608" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_608_SPEC_VERSION"/> + <enum value=""XR_META_extension_608"" name="XR_META_extension_608_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_609" number="609" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_609_SPEC_VERSION"/> + <enum value=""XR_META_extension_609"" name="XR_META_extension_609_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_tile_properties_hint" number="610" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_tile_properties_hint_SPEC_VERSION"/> + <enum value=""XR_META_tile_properties_hint"" name="XR_META_TILE_PROPERTIES_HINT_EXTENSION_NAME"/> + + <type name="XrExtent3DiMETA"/> + <type name="XrTilePropertiesMETA"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_TILE_PROPERTIES_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_TILE_PROPERTIES_HINT_META"/> + <type name="XrTilePropertiesHintMETA"/> + <command name="xrSetTilePropertiesHintMETA"/> + </require> + </extension> + + <extension name="XR_META_extension_611" number="611" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_611_SPEC_VERSION"/> + <enum value=""XR_META_extension_611"" name="XR_META_extension_611_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_612" number="612" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_612_SPEC_VERSION"/> + <enum value=""XR_META_extension_612"" name="XR_META_extension_612_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_613" number="613" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_613_SPEC_VERSION"/> + <enum value=""XR_META_extension_613"" name="XR_META_extension_613_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_614" number="614" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_614_SPEC_VERSION"/> + <enum value=""XR_META_extension_614"" name="XR_META_extension_614_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_615" number="615" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_615_SPEC_VERSION"/> + <enum value=""XR_META_extension_615"" name="XR_META_extension_615_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_616" number="616" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_616_SPEC_VERSION"/> + <enum value=""XR_META_extension_616"" name="XR_META_extension_616_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_617" number="617" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_617_SPEC_VERSION"/> + <enum value=""XR_META_extension_617"" name="XR_META_extension_617_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_618" number="618" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_618_SPEC_VERSION"/> + <enum value=""XR_META_extension_618"" name="XR_META_extension_618_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_619" number="619" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_619_SPEC_VERSION"/> + <enum value=""XR_META_extension_619"" name="XR_META_extension_619_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_620" number="620" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_620_SPEC_VERSION"/> + <enum value=""XR_META_extension_620"" name="XR_META_extension_620_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_621" number="621" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_621_SPEC_VERSION"/> + <enum value=""XR_META_extension_621"" name="XR_META_extension_621_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_622" number="622" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_622_SPEC_VERSION"/> + <enum value=""XR_META_extension_622"" name="XR_META_extension_622_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_623" number="623" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_623_SPEC_VERSION"/> + <enum value=""XR_META_extension_623"" name="XR_META_extension_623_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_624" number="624" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_624_SPEC_VERSION"/> + <enum value=""XR_META_extension_624"" name="XR_META_extension_624_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_625" number="625" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_625_SPEC_VERSION"/> + <enum value=""XR_META_extension_625"" name="XR_META_extension_625_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_626" number="626" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_626_SPEC_VERSION"/> + <enum value=""XR_META_extension_626"" name="XR_META_extension_626_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_627" number="627" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_627_SPEC_VERSION"/> + <enum value=""XR_META_extension_627"" name="XR_META_extension_627_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_628" number="628" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_628_SPEC_VERSION"/> + <enum value=""XR_META_extension_628"" name="XR_META_extension_628_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_629" number="629" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_629_SPEC_VERSION"/> + <enum value=""XR_META_extension_629"" name="XR_META_extension_629_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_630" number="630" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_630_SPEC_VERSION"/> + <enum value=""XR_META_extension_630"" name="XR_META_extension_630_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_631" number="631" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_631_SPEC_VERSION"/> + <enum value=""XR_META_extension_631"" name="XR_META_extension_631_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_632" number="632" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_632_SPEC_VERSION"/> + <enum value=""XR_META_extension_632"" name="XR_META_extension_632_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_633" number="633" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_633_SPEC_VERSION"/> + <enum value=""XR_META_extension_633"" name="XR_META_extension_633_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_634" number="634" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_634_SPEC_VERSION"/> + <enum value=""XR_META_extension_634"" name="XR_META_extension_634_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_635" number="635" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_635_SPEC_VERSION"/> + <enum value=""XR_META_extension_635"" name="XR_META_extension_635_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_636" number="636" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_636_SPEC_VERSION"/> + <enum value=""XR_META_extension_636"" name="XR_META_extension_636_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_637" number="637" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_637_SPEC_VERSION"/> + <enum value=""XR_META_extension_637"" name="XR_META_extension_637_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_638" number="638" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_638_SPEC_VERSION"/> + <enum value=""XR_META_extension_638"" name="XR_META_extension_638_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_639" number="639" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_639_SPEC_VERSION"/> + <enum value=""XR_META_extension_639"" name="XR_META_extension_639_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_640" number="640" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_640_SPEC_VERSION"/> + <enum value=""XR_META_extension_640"" name="XR_META_extension_640_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_641" number="641" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_641_SPEC_VERSION"/> + <enum value=""XR_META_extension_641"" name="XR_META_extension_641_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_642" number="642" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_642_SPEC_VERSION"/> + <enum value=""XR_META_extension_642"" name="XR_META_extension_642_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_643" number="643" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_643_SPEC_VERSION"/> + <enum value=""XR_META_extension_643"" name="XR_META_extension_643_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_644" number="644" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_644_SPEC_VERSION"/> + <enum value=""XR_META_extension_644"" name="XR_META_extension_644_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_645" number="645" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_645_SPEC_VERSION"/> + <enum value=""XR_META_extension_645"" name="XR_META_extension_645_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_646" number="646" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_646_SPEC_VERSION"/> + <enum value=""XR_META_extension_646"" name="XR_META_extension_646_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_647" number="647" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_647_SPEC_VERSION"/> + <enum value=""XR_META_extension_647"" name="XR_META_extension_647_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_648" number="648" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_648_SPEC_VERSION"/> + <enum value=""XR_META_extension_648"" name="XR_META_extension_648_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_649" number="649" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_649_SPEC_VERSION"/> + <enum value=""XR_META_extension_649"" name="XR_META_extension_649_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_650" number="650" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_650_SPEC_VERSION"/> + <enum value=""XR_META_extension_650"" name="XR_META_extension_650_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_651" number="651" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_651_SPEC_VERSION"/> + <enum value=""XR_META_extension_651"" name="XR_META_extension_651_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_652" number="652" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_652_SPEC_VERSION"/> + <enum value=""XR_META_extension_652"" name="XR_META_extension_652_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_653" number="653" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_653_SPEC_VERSION"/> + <enum value=""XR_META_extension_653"" name="XR_META_extension_653_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_654" number="654" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_654_SPEC_VERSION"/> + <enum value=""XR_META_extension_654"" name="XR_META_extension_654_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_655" number="655" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_655_SPEC_VERSION"/> + <enum value=""XR_META_extension_655"" name="XR_META_extension_655_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_656" number="656" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_656_SPEC_VERSION"/> + <enum value=""XR_META_extension_656"" name="XR_META_extension_656_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_657" number="657" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_657_SPEC_VERSION"/> + <enum value=""XR_META_extension_657"" name="XR_META_extension_657_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_658" number="658" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_658_SPEC_VERSION"/> + <enum value=""XR_META_extension_658"" name="XR_META_extension_658_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_659" number="659" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_659_SPEC_VERSION"/> + <enum value=""XR_META_extension_659"" name="XR_META_extension_659_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_660" number="660" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_660_SPEC_VERSION"/> + <enum value=""XR_META_extension_660"" name="XR_META_extension_660_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_661" number="661" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_661_SPEC_VERSION"/> + <enum value=""XR_META_extension_661"" name="XR_META_extension_661_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_662" number="662" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_662_SPEC_VERSION"/> + <enum value=""XR_META_extension_662"" name="XR_META_extension_662_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_663" number="663" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_663_SPEC_VERSION"/> + <enum value=""XR_META_extension_663"" name="XR_META_extension_663_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_664" number="664" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_664_SPEC_VERSION"/> + <enum value=""XR_META_extension_664"" name="XR_META_extension_664_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_665" number="665" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_665_SPEC_VERSION"/> + <enum value=""XR_META_extension_665"" name="XR_META_extension_665_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_666" number="666" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_666_SPEC_VERSION"/> + <enum value=""XR_META_extension_666"" name="XR_META_extension_666_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_667" number="667" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_667_SPEC_VERSION"/> + <enum value=""XR_META_extension_667"" name="XR_META_extension_667_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_668" number="668" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_668_SPEC_VERSION"/> + <enum value=""XR_META_extension_668"" name="XR_META_extension_668_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_669" number="669" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_669_SPEC_VERSION"/> + <enum value=""XR_META_extension_669"" name="XR_META_extension_669_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_670" number="670" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_670_SPEC_VERSION"/> + <enum value=""XR_META_extension_670"" name="XR_META_extension_670_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_671" number="671" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_671_SPEC_VERSION"/> + <enum value=""XR_META_extension_671"" name="XR_META_extension_671_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_672" number="672" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_672_SPEC_VERSION"/> + <enum value=""XR_META_extension_672"" name="XR_META_extension_672_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_673" number="673" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_673_SPEC_VERSION"/> + <enum value=""XR_META_extension_673"" name="XR_META_extension_673_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_674" number="674" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_674_SPEC_VERSION"/> + <enum value=""XR_META_extension_674"" name="XR_META_extension_674_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_675" number="675" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_675_SPEC_VERSION"/> + <enum value=""XR_META_extension_675"" name="XR_META_extension_675_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_676" number="676" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_676_SPEC_VERSION"/> + <enum value=""XR_META_extension_676"" name="XR_META_extension_676_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_677" number="677" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_677_SPEC_VERSION"/> + <enum value=""XR_META_extension_677"" name="XR_META_extension_677_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_678" number="678" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_678_SPEC_VERSION"/> + <enum value=""XR_META_extension_678"" name="XR_META_extension_678_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_679" number="679" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_679_SPEC_VERSION"/> + <enum value=""XR_META_extension_679"" name="XR_META_extension_679_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_680" number="680" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_680_SPEC_VERSION"/> + <enum value=""XR_META_extension_680"" name="XR_META_extension_680_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_681" number="681" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_681_SPEC_VERSION"/> + <enum value=""XR_META_extension_681"" name="XR_META_extension_681_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_682" number="682" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_682_SPEC_VERSION"/> + <enum value=""XR_META_extension_682"" name="XR_META_extension_682_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_683" number="683" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_683_SPEC_VERSION"/> + <enum value=""XR_META_extension_683"" name="XR_META_extension_683_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_684" number="684" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_684_SPEC_VERSION"/> + <enum value=""XR_META_extension_684"" name="XR_META_extension_684_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_685" number="685" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_685_SPEC_VERSION"/> + <enum value=""XR_META_extension_685"" name="XR_META_extension_685_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_686" number="686" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_686_SPEC_VERSION"/> + <enum value=""XR_META_extension_686"" name="XR_META_extension_686_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_687" number="687" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_687_SPEC_VERSION"/> + <enum value=""XR_META_extension_687"" name="XR_META_extension_687_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_688" number="688" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_688_SPEC_VERSION"/> + <enum value=""XR_META_extension_688"" name="XR_META_extension_688_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_689" number="689" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_689_SPEC_VERSION"/> + <enum value=""XR_META_extension_689"" name="XR_META_extension_689_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_690" number="690" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_690_SPEC_VERSION"/> + <enum value=""XR_META_extension_690"" name="XR_META_extension_690_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_691" number="691" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_691_SPEC_VERSION"/> + <enum value=""XR_META_extension_691"" name="XR_META_extension_691_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_692" number="692" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_692_SPEC_VERSION"/> + <enum value=""XR_META_extension_692"" name="XR_META_extension_692_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_693" number="693" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_693_SPEC_VERSION"/> + <enum value=""XR_META_extension_693"" name="XR_META_extension_693_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_hand_tracking_unextrapolated_poses" number="694" depends="XR_VERSION_1_0+XR_EXT_hand_tracking" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_hand_tracking_unextrapolated_poses_SPEC_VERSION"/> + <enum value=""XR_META_hand_tracking_unextrapolated_poses"" name="XR_META_HAND_TRACKING_UNEXTRAPOLATED_POSES_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_HAND_TRACKING_UNEXTRAPOLATED_POSES_REQUEST_META"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_HAND_TRACKING_UNEXTRAPOLATED_POSES_META"/> + + <type name="XrHandTrackingUnextrapolatedPosesRequestMETA"/> + <type name="XrHandTrackingUnextrapolatedPosesMETA"/> + </require> + </extension> + + <extension name="XR_META_hand_tracking_frequency_hint" number="695" depends="XR_VERSION_1_0+XR_EXT_hand_tracking" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_hand_tracking_frequency_hint_SPEC_VERSION"/> + <enum value=""XR_META_hand_tracking_frequency_hint"" name="XR_META_HAND_TRACKING_FREQUENCY_HINT_EXTENSION_NAME"/> + + <type name="XrHandTrackingFrequencyHintMETA"/> + <command name="xrSetHandTrackingFrequencyHintMETA"/> + </require> + </extension> + + <extension name="XR_META_hand_tracking_wide_motion_mode2" number="696" depends="XR_VERSION_1_0+XR_EXT_hand_tracking+XR_EXT_hand_tracking_data_source" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_META_hand_tracking_wide_motion_mode2_SPEC_VERSION"/> + <enum value=""XR_META_hand_tracking_wide_motion_mode2"" name="XR_META_HAND_TRACKING_WIDE_MOTION_MODE2_EXTENSION_NAME"/> + + <enum offset="0" extends="XrHandTrackingDataSourceEXT" name="XR_HAND_TRACKING_DATA_SOURCE_UNOBSTRUCTED_WIDE_MOTION_META" comment="This data source value indicates that the hand tracking system should use wide motion mode inference to provide hand poses when the hands are not directly visible to the tracking cameras"/> + </require> + </extension> + + <extension name="XR_META_extension_697" number="697" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_697_SPEC_VERSION"/> + <enum value=""XR_META_extension_697"" name="XR_META_extension_697_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_698" number="698" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_698_SPEC_VERSION"/> + <enum value=""XR_META_extension_698"" name="XR_META_extension_698_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_699" number="699" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_699_SPEC_VERSION"/> + <enum value=""XR_META_extension_699"" name="XR_META_extension_699_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_KHR_egl_enable" number="700" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_KHR_egl_enable_SPEC_VERSION"/> + <enum value=""XR_KHR_egl_enable"" name="XR_KHR_EGL_ENABLE_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_light_estimation" number="701" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ANDROID_light_estimation_SPEC_VERSION"/> + <enum value=""XR_ANDROID_light_estimation"" name="XR_ANDROID_LIGHT_ESTIMATION_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_LIGHT_ESTIMATOR_CREATE_INFO_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_LIGHT_ESTIMATE_GET_INFO_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_LIGHT_ESTIMATE_ANDROID"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_DIRECTIONAL_LIGHT_ANDROID"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SPHERICAL_HARMONICS_ANDROID"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_AMBIENT_LIGHT_ANDROID"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_SYSTEM_LIGHT_ESTIMATION_PROPERTIES_ANDROID"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_LIGHT_ESTIMATOR_ANDROID" comment="XrLightEstimatorANDROID"/> + + <type name="XrSystemLightEstimationPropertiesANDROID"/> + <type name="XrLightEstimatorANDROID"/> + <type name="XrLightEstimatorCreateInfoANDROID"/> + <type name="XrLightEstimateGetInfoANDROID"/> + <type name="XrLightEstimateANDROID"/> + <type name="XrDirectionalLightANDROID"/> + <type name="XrAmbientLightANDROID"/> + <type name="XrSphericalHarmonicsANDROID"/> + + <type name="XrLightEstimateStateANDROID"/> + <type name="XrSphericalHarmonicsKindANDROID"/> + + <command name="xrCreateLightEstimatorANDROID"/> + <command name="xrDestroyLightEstimatorANDROID"/> + <command name="xrGetLightEstimateANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_anchor_sharing_export" number="702" type="instance" supported="openxr" protect="XR_USE_PLATFORM_ANDROID"> + <require> + <enum value="1" name="XR_ANDROID_anchor_sharing_export_SPEC_VERSION"/> + <enum value=""XR_ANDROID_anchor_sharing_export"" name="XR_ANDROID_ANCHOR_SHARING_EXPORT_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_ANCHOR_SHARING_INFO_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_ANCHOR_SHARING_TOKEN_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SYSTEM_ANCHOR_SHARING_EXPORT_PROPERTIES_ANDROID"/> + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_ANCHOR_NOT_OWNED_BY_CALLER_ANDROID" comment="Operation not allowed because anchor is not owned by the slink:XrSession in which the function is being called."/> + + <type name="XrAnchorSharingInfoANDROID"/> + <type name="XrAnchorSharingTokenANDROID"/> + <type name="XrSystemAnchorSharingExportPropertiesANDROID"/> + + <command name="xrShareAnchorANDROID"/> + <command name="xrUnshareAnchorANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_703" number="703" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_703_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_703"" name="XR_ANDROID_EXTENSION_703_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_704" number="704" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_704_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_704"" name="XR_ANDROID_EXTENSION_704_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_mouse_interaction" number="705" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_ANDROID_mouse_interaction_SPEC_VERSION"/> + <enum value=""XR_ANDROID_mouse_interaction"" name="XR_ANDROID_MOUSE_INTERACTION_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/android/mouse_interaction_android"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_706" number="706" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_706_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_706"" name="XR_ANDROID_EXTENSION_706_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_707" number="707" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_707_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_707"" name="XR_ANDROID_EXTENSION_707_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_trackables_marker" number="708" type="instance" supported="openxr" depends="XR_ANDROID_trackables" deprecatedby="XR_EXT_spatial_marker_tracking"> + <require> + <enum value="1" name="XR_ANDROID_trackables_marker_SPEC_VERSION"/> + <enum value=""XR_ANDROID_trackables_marker"" name="XR_ANDROID_TRACKABLES_MARKER_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_MARKER_TRACKING_PROPERTIES_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_TRACKABLE_MARKER_CONFIGURATION_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_TRACKABLE_MARKER_ANDROID"/> + + <enum offset="0" extends="XrTrackableTypeANDROID" name="XR_TRACKABLE_TYPE_MARKER_ANDROID" comment="Indicates that the trackable is a marker."/> + + <type name="XrTrackableMarkerTrackingModeANDROID"/> + <type name="XrTrackableMarkerDictionaryANDROID"/> + + <type name="XrSystemMarkerTrackingPropertiesANDROID"/> + <type name="XrTrackableMarkerConfigurationANDROID"/> + <type name="XrTrackableMarkerDatabaseANDROID"/> + <type name="XrTrackableMarkerDatabaseEntryANDROID"/> + <type name="XrTrackableMarkerANDROID"/> + + <command name="xrGetTrackableMarkerANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_trackables_qr_code" number="709" type="instance" supported="openxr" depends="XR_ANDROID_trackables" deprecatedby="XR_EXT_spatial_marker_tracking"> + <require> + <enum value="1" name="XR_ANDROID_trackables_qr_code_SPEC_VERSION"/> + <enum value=""XR_ANDROID_trackables_qr_code"" name="XR_ANDROID_TRACKABLES_QR_CODE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_QR_CODE_TRACKING_PROPERTIES_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_TRACKABLE_QR_CODE_CONFIGURATION_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_TRACKABLE_QR_CODE_ANDROID"/> + + <enum offset="0" extends="XrTrackableTypeANDROID" name="XR_TRACKABLE_TYPE_QR_CODE_ANDROID" comment="Indicates that the trackable is a QR code."/> + + <type name="XrQrCodeTrackingModeANDROID"/> + + <type name="XrSystemQrCodeTrackingPropertiesANDROID"/> + <type name="XrTrackableQrCodeConfigurationANDROID"/> + <type name="XrTrackableQrCodeANDROID"/> + + <command name="xrGetTrackableQrCodeANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_trackables_image" number="710" type="instance" supported="openxr" depends="XR_EXT_future+XR_ANDROID_trackables"> + <require> + <enum value="1" name="XR_ANDROID_trackables_image_SPEC_VERSION"/> + <enum value=""XR_ANDROID_trackables_image"" name="XR_ANDROID_TRACKABLES_IMAGE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_IMAGE_TRACKING_PROPERTIES_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_TRACKABLE_IMAGE_DATABASE_ENTRY_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_TRACKABLE_IMAGE_DATABASE_CREATE_INFO_ANDROID"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_CREATE_TRACKABLE_IMAGE_DATABASE_COMPLETION_ANDROID"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_TRACKABLE_IMAGE_CONFIGURATION_ANDROID"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_TRACKABLE_IMAGE_ANDROID"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_IMAGE_TRACKING_LOST_ANDROID"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_TRACKABLE_IMAGE_DATABASE_ANDROID" comment="XrTrackableImageDatabaseANDROID"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_IMAGE_FORMAT_UNSUPPORTED_ANDROID" comment="Indicates that the input reference image format is not supported."/> + + <enum offset="0" extends="XrTrackableTypeANDROID" name="XR_TRACKABLE_TYPE_IMAGE_ANDROID" comment="Indicates that the trackable is an image."/> + + <type name="XrTrackableImageDatabaseANDROID"/> + + <type name="XrTrackableImageTrackingModeANDROID"/> + <type name="XrTrackableImageFormatANDROID"/> + + <type name="XrSystemImageTrackingPropertiesANDROID"/> + <type name="XrTrackableImageDatabaseEntryANDROID"/> + <type name="XrTrackableImageDatabaseCreateInfoANDROID"/> + <type name="XrCreateTrackableImageDatabaseCompletionANDROID"/> + <type name="XrTrackableImageConfigurationANDROID"/> + <type name="XrTrackableImageANDROID"/> + <type name="XrEventDataImageTrackingLostANDROID"/> + + <command name="xrCreateTrackableImageDatabaseAsyncANDROID"/> + <command name="xrCreateTrackableImageDatabaseCompleteANDROID"/> + <command name="xrDestroyTrackableImageDatabaseANDROID"/> + <command name="xrAddTrackableImageDatabaseANDROID"/> + <command name="xrRemoveTrackableImageDatabaseANDROID"/> + <command name="xrGetTrackableImageANDROID"/> + </require> + </extension> + + <extension name="XR_KHR_maintenance1" number="711" type="instance" supported="openxr" promotedto="XR_VERSION_1_1" ratified="openxr"> + <require> + <enum value="1" name="XR_KHR_maintenance1_SPEC_VERSION"/> + <enum value=""XR_KHR_maintenance1"" name="XR_KHR_MAINTENANCE1_EXTENSION_NAME"/> + + <!-- new structs --> + <type name="XrColor3fKHR"/> + <type name="XrExtent3DfKHR"/> + <type name="XrSpherefKHR"/> + <type name="XrBoxfKHR"/> + <type name="XrFrustumfKHR"/> + + + <!-- error codes --> + <enum extends="XrResult" name="XR_ERROR_EXTENSION_DEPENDENCY_NOT_ENABLED_KHR" alias="XR_ERROR_EXTENSION_DEPENDENCY_NOT_ENABLED"/> + <enum extends="XrResult" name="XR_ERROR_PERMISSION_INSUFFICIENT_KHR" alias="XR_ERROR_PERMISSION_INSUFFICIENT"/> + + </require> + + <!-- grip_surface --> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)"> + <extend interaction_profile_path="/interaction_profiles/khr/simple_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/google/daydream_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/htc/vive_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/microsoft/motion_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/oculus/go_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/oculus/touch_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/valve/index_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_MSFT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/microsoft/hand_interaction"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_HUAWEI_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/huawei/controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_HTC_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/htc/hand_interaction"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_HTC_vive_cosmos_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_cosmos_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_HTC_vive_focus3_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_focus3_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_HTCX_vive_tracker_interaction"> + <extend interaction_profile_path="/interaction_profiles/htc/vive_tracker_htcx"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_EXT_samsung_odyssey_controller"> + <extend interaction_profile_path="/interaction_profiles/samsung/odyssey_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_EXT_hp_mixed_reality_controller"> + <extend interaction_profile_path="/interaction_profiles/hp/mixed_reality_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_ML_ml2_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/ml/ml2_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_FB_touch_controller_pro"> + <extend interaction_profile_path="/interaction_profiles/facebook/touch_controller_pro"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_META_touch_controller_plus"> + <extend interaction_profile_path="/interaction_profiles/meta/touch_controller_plus"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_BD_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_neo3_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico4_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + <extend interaction_profile_path="/interaction_profiles/bytedance/pico_g3_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_OPPO_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/oppo/mr_controller_oppo"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_YVR_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/yvr/touch_controller_yvr"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_VARJO_xr4_controller_interaction"> + <extend interaction_profile_path="/interaction_profiles/varjo/xr-4_controller"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/ext/hand_interaction_ext"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require comment="grip_surface/pose (obsoletes palm_ext/pose)" depends="XR_LOGITECH_mx_ink_stylus_interaction"> + <extend interaction_profile_path="/interaction_profiles/logitech/mx_ink_stylus_logitech"> + <component subpath="/input/grip_surface/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <!-- grip_surface --> + </extension> + + <extension name="XR_KHR_generic_controller" number="712" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="1" name="XR_KHR_generic_controller_SPEC_VERSION"/> + <enum value=""XR_KHR_generic_controller"" name="XR_KHR_GENERIC_CONTROLLER_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/khr/generic_controller"/> + </require> + <require depends="XR_EXT_dpad_binding"> + <extend interaction_profile_path="/interaction_profiles/khr/generic_controller"> + <component subpath="/input/thumbstick/dpad_up" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_down" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_left" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + <component subpath="/input/thumbstick/dpad_right" type="XR_ACTION_TYPE_BOOLEAN_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/khr/generic_controller"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/khr/generic_controller"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_VARJO_extension_713" number="713" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VARJO_extension_713_SPEC_VERSION"/> + <enum value=""XR_VARJO_extension_713"" name="XR_VARJO_EXTENSION_713_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VARJO_extension_714" number="714" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VARJO_extension_714_SPEC_VERSION"/> + <enum value=""XR_VARJO_extension_714"" name="XR_VARJO_EXTENSION_714_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_VARJO_extension_715" number="715" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_VARJO_extension_715_SPEC_VERSION"/> + <enum value=""XR_VARJO_extension_715"" name="XR_VARJO_EXTENSION_715_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDX_extension_716" number="716" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDX_extension_716_SPEC_VERSION"/> + <enum value=""XR_ANDROIDX_extension_716"" name="XR_ANDROIDX_EXTENSION_716_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDX_extension_717" number="717" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDX_extension_717_SPEC_VERSION"/> + <enum value=""XR_ANDROIDX_extension_717"" name="XR_ANDROIDX_EXTENSION_717_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDX_extension_718" number="718" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDX_extension_718_SPEC_VERSION"/> + <enum value=""XR_ANDROIDX_extension_718"" name="XR_ANDROIDX_EXTENSION_718_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_scene_meshing" number="719" type="instance" supported="openxr"> + <require> + <enum value="3" name="XR_ANDROID_scene_meshing_SPEC_VERSION"/> + <enum value=""XR_ANDROID_scene_meshing"" name="XR_ANDROID_SCENE_MESHING_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_SCENE_MESHING_PROPERTIES_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SCENE_MESHING_TRACKER_CREATE_INFO_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SCENE_MESH_SNAPSHOT_CREATE_INFO_ANDROID"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SCENE_MESH_SNAPSHOT_CREATION_RESULT_ANDROID"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SCENE_SUBMESH_STATE_ANDROID"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_SCENE_SUBMESH_DATA_ANDROID"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SCENE_MESHING_TRACKER_ANDROID" comment="XrSceneMeshingTrackerANDROID"/> + <enum offset="1" extends="XrObjectType" name="XR_OBJECT_TYPE_SCENE_MESH_SNAPSHOT_ANDROID" comment="XrSceneMeshSnapshotANDROID"/> + + <type name="XrSceneMeshingTrackerANDROID"/> + <type name="XrSceneMeshSnapshotANDROID"/> + <type name="XrSystemSceneMeshingPropertiesANDROID"/> + <type name="XrSceneMeshingTrackerCreateInfoANDROID"/> + <type name="XrSceneMeshSnapshotCreateInfoANDROID"/> + <type name="XrSceneMeshSnapshotCreationResultANDROID"/> + <type name="XrSceneSubmeshStateANDROID"/> + <type name="XrSceneSubmeshDataANDROID"/> + <type name="XrSceneMeshSemanticLabelSetANDROID"/> + <type name="XrSceneMeshSemanticLabelANDROID"/> + <type name="XrSceneMeshTrackingStateANDROID"/> + + <command name="xrEnumerateSupportedSemanticLabelSetsANDROID"/> + <command name="xrCreateSceneMeshingTrackerANDROID"/> + <command name="xrDestroySceneMeshingTrackerANDROID"/> + <command name="xrCreateSceneMeshSnapshotANDROID"/> + <command name="xrDestroySceneMeshSnapshotANDROID"/> + <command name="xrGetAllSubmeshStatesANDROID"/> + <command name="xrGetSubmeshDataANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROIDX_extension_720" number="720" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDX_extension_720_SPEC_VERSION"/> + <enum value=""XR_ANDROIDX_extension_720"" name="XR_ANDROIDX_EXTENSION_720_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDX_extension_721" number="721" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDX_extension_721_SPEC_VERSION"/> + <enum value=""XR_ANDROIDX_extension_721"" name="XR_ANDROIDX_EXTENSION_721_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDX_extension_722" number="722" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDX_extension_722_SPEC_VERSION"/> + <enum value=""XR_ANDROIDX_extension_722"" name="XR_ANDROIDX_EXTENSION_722_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDX_extension_723" number="723" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDX_extension_723_SPEC_VERSION"/> + <enum value=""XR_ANDROIDX_extension_723"" name="XR_ANDROIDX_EXTENSION_723_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDX_extension_724" number="724" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDX_extension_724_SPEC_VERSION"/> + <enum value=""XR_ANDROIDX_extension_724"" name="XR_ANDROIDX_EXTENSION_724_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDX_extension_725" number="725" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDX_extension_725_SPEC_VERSION"/> + <enum value=""XR_ANDROIDX_extension_725"" name="XR_ANDROIDX_EXTENSION_725_EXTENSION_NAME"/> + </require> + </extension> + <extension name="XR_ANDROIDSYS_extension_726" number="726" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDSYS_extension_726_SPEC_VERSION"/> + <enum value=""XR_ANDROIDSYS_extension_726"" name="XR_ANDROIDSYS_EXTENSION_726_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDSYS_extension_727" number="727" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDSYS_extension_727_SPEC_VERSION"/> + <enum value=""XR_ANDROIDSYS_extension_727"" name="XR_ANDROIDSYS_EXTENSION_727_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDSYS_extension_728" number="728" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDSYS_extension_728_SPEC_VERSION"/> + <enum value=""XR_ANDROIDSYS_extension_728"" name="XR_ANDROIDSYS_EXTENSION_728_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDSYS_extension_729" number="729" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDSYS_extension_729_SPEC_VERSION"/> + <enum value=""XR_ANDROIDSYS_extension_729"" name="XR_ANDROIDSYS_EXTENSION_729_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDSYS_extension_730" number="730" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDSYS_extension_730_SPEC_VERSION"/> + <enum value=""XR_ANDROIDSYS_extension_730"" name="XR_ANDROIDSYS_EXTENSION_730_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDSYS_extension_731" number="731" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDSYS_extension_731_SPEC_VERSION"/> + <enum value=""XR_ANDROIDSYS_extension_731"" name="XR_ANDROIDSYS_EXTENSION_731_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDSYS_extension_732" number="732" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDSYS_extension_732_SPEC_VERSION"/> + <enum value=""XR_ANDROIDSYS_extension_732"" name="XR_ANDROIDSYS_EXTENSION_732_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDSYS_extension_733" number="733" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDSYS_extension_733_SPEC_VERSION"/> + <enum value=""XR_ANDROIDSYS_extension_733"" name="XR_ANDROIDSYS_EXTENSION_733_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDSYS_extension_734" number="734" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDSYS_extension_734_SPEC_VERSION"/> + <enum value=""XR_ANDROIDSYS_extension_734"" name="XR_ANDROIDSYS_EXTENSION_734_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROIDSYS_extension_735" number="735" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROIDSYS_extension_735_SPEC_VERSION"/> + <enum value=""XR_ANDROIDSYS_extension_735"" name="XR_ANDROIDSYS_EXTENSION_735_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LEIA_extension_736" number="736" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LEIA_extension_736_SPEC_VERSION"/> + <enum value=""XR_LEIA_extension_736"" name="XR_LEIA_EXTENSION_736_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LEIA_extension_737" number="737" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LEIA_extension_737_SPEC_VERSION"/> + <enum value=""XR_LEIA_extension_737"" name="XR_LEIA_EXTENSION_737_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LEIA_extension_738" number="738" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_LEIA_extension_738_SPEC_VERSION"/> + <enum value=""XR_LEIA_extension_738"" name="XR_LEIA_EXTENSION_738_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_739" number="739" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_739_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_739"" name="XR_EXT_EXTENSION_739_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_740" number="740" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_740_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_740"" name="XR_EXT_EXTENSION_740_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_spatial_entity" number="741" type="instance" supported="openxr" depends="XR_EXT_future" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_spatial_entity_SPEC_VERSION"/> + <enum value=""XR_EXT_spatial_entity"" name="XR_EXT_SPATIAL_ENTITY_EXTENSION_NAME"/> + + <type name="XR_NULL_SPATIAL_ENTITY_ID_EXT"/> + <type name="XR_NULL_SPATIAL_BUFFER_ID_EXT"/> + + <type name="XrSpatialEntityIdEXT"/> + <type name="XrSpatialBufferIdEXT"/> + + <type name="XrSpatialEntityEXT"/> + <type name="XrSpatialContextEXT"/> + <type name="XrSpatialSnapshotEXT"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SPATIAL_ENTITY_EXT" comment="XrSpatialEntityEXT"/> + <enum offset="1" extends="XrObjectType" name="XR_OBJECT_TYPE_SPATIAL_CONTEXT_EXT" comment="XrSpatialContextEXT"/> + <enum offset="2" extends="XrObjectType" name="XR_OBJECT_TYPE_SPATIAL_SNAPSHOT_EXT" comment="XrSpatialSnapshotEXT"/> + + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_CAPABILITY_UNSUPPORTED_EXT" comment="The specified spatial capability is not supported by the runtime or the system."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ENTITY_ID_INVALID_EXT" comment="The specified spatial entity id is invalid or an entity with that id does not exist in the environment."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_BUFFER_ID_INVALID_EXT" comment="The specified spatial buffer id is invalid or does not exist in the spatial snapshot being used to query for the buffer data."/> + <enum offset="4" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_COMPONENT_UNSUPPORTED_FOR_CAPABILITY_EXT" comment="The specified spatial component is not supported by the runtime or the system for the given capability."/> + <enum offset="5" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_CAPABILITY_CONFIGURATION_INVALID_EXT" comment="The specified spatial capability configuration is invalid."/> + <enum offset="6" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_COMPONENT_NOT_ENABLED_EXT" comment="The specified spatial component is not enabled for the spatial context."/> + + <type name="XrSpatialCapabilityEXT"/> + <type name="XrSpatialCapabilityFeatureEXT"/> + <type name="XrSpatialComponentTypeEXT"/> + <type name="XrSpatialEntityTrackingStateEXT"/> + <type name="XrSpatialBufferTypeEXT"/> + + <type name="XrSpatialCapabilityComponentTypesEXT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_CAPABILITY_COMPONENT_TYPES_EXT"/> + <type name="XrSpatialCapabilityConfigurationBaseHeaderEXT"/> + <type name="XrSpatialContextCreateInfoEXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_CONTEXT_CREATE_INFO_EXT"/> + <type name="XrCreateSpatialContextCompletionEXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_CREATE_SPATIAL_CONTEXT_COMPLETION_EXT"/> + <type name="XrSpatialDiscoverySnapshotCreateInfoEXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPATIAL_DISCOVERY_SNAPSHOT_CREATE_INFO_EXT"/> + <type name="XrCreateSpatialDiscoverySnapshotCompletionInfoEXT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_INFO_EXT"/> + <type name="XrCreateSpatialDiscoverySnapshotCompletionEXT"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_CREATE_SPATIAL_DISCOVERY_SNAPSHOT_COMPLETION_EXT"/> + <type name="XrSpatialComponentDataQueryConditionEXT"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_CONDITION_EXT"/> + <type name="XrSpatialComponentDataQueryResultEXT"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_DATA_QUERY_RESULT_EXT"/> + <type name="XrSpatialBufferEXT"/> + <type name="XrSpatialBufferGetInfoEXT"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_SPATIAL_BUFFER_GET_INFO_EXT"/> + <type name="XrSpatialBounded2DDataEXT"/> + <type name="XrSpatialComponentBounded2DListEXT"/> + <enum offset="9" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_BOUNDED_2D_LIST_EXT"/> + <type name="XrSpatialComponentBounded3DListEXT"/> + <enum offset="10" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_BOUNDED_3D_LIST_EXT"/> + <type name="XrSpatialComponentParentListEXT"/> + <enum offset="11" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_PARENT_LIST_EXT"/> + <type name="XrSpatialMeshDataEXT"/> + <type name="XrSpatialComponentMesh3DListEXT"/> + <enum offset="12" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_MESH_3D_LIST_EXT"/> + <type name="XrSpatialEntityFromIdCreateInfoEXT"/> + <enum offset="13" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_FROM_ID_CREATE_INFO_EXT"/> + <type name="XrSpatialUpdateSnapshotCreateInfoEXT"/> + <enum offset="14" extends="XrStructureType" name="XR_TYPE_SPATIAL_UPDATE_SNAPSHOT_CREATE_INFO_EXT"/> + <type name="XrEventDataSpatialDiscoveryRecommendedEXT"/> + <enum offset="15" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPATIAL_DISCOVERY_RECOMMENDED_EXT"/> + <type name="XrSpatialFilterTrackingStateEXT"/> + <enum offset="16" extends="XrStructureType" name="XR_TYPE_SPATIAL_FILTER_TRACKING_STATE_EXT"/> + + <command name="xrEnumerateSpatialCapabilitiesEXT"/> + <command name="xrEnumerateSpatialCapabilityComponentTypesEXT"/> + <command name="xrEnumerateSpatialCapabilityFeaturesEXT"/> + <command name="xrCreateSpatialContextAsyncEXT"/> + <command name="xrCreateSpatialContextCompleteEXT"/> + <command name="xrDestroySpatialContextEXT"/> + <command name="xrCreateSpatialDiscoverySnapshotAsyncEXT"/> + <command name="xrCreateSpatialDiscoverySnapshotCompleteEXT"/> + <command name="xrQuerySpatialComponentDataEXT"/> + <command name="xrDestroySpatialSnapshotEXT"/> + <command name="xrCreateSpatialEntityFromIdEXT"/> + <command name="xrDestroySpatialEntityEXT"/> + <command name="xrCreateSpatialUpdateSnapshotEXT"/> + <command name="xrGetSpatialBufferStringEXT"/> + <command name="xrGetSpatialBufferUint8EXT"/> + <command name="xrGetSpatialBufferUint16EXT"/> + <command name="xrGetSpatialBufferUint32EXT"/> + <command name="xrGetSpatialBufferFloatEXT"/> + <command name="xrGetSpatialBufferVector2fEXT"/> + <command name="xrGetSpatialBufferVector3fEXT"/> + + </require> + </extension> + + <extension name="XR_EXT_spatial_plane_tracking" number="742" type="instance" supported="openxr" depends="XR_EXT_spatial_entity" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_spatial_plane_tracking_SPEC_VERSION"/> + <enum value=""XR_EXT_spatial_plane_tracking"" name="XR_EXT_SPATIAL_PLANE_TRACKING_EXTENSION_NAME"/> + + <enum offset="0" extends="XrSpatialCapabilityEXT" name="XR_SPATIAL_CAPABILITY_PLANE_TRACKING_EXT" comment="Plane tracking"/> + + <enum offset="0" extends="XrSpatialComponentTypeEXT" name="XR_SPATIAL_COMPONENT_TYPE_PLANE_ALIGNMENT_EXT" comment="Component that provides the plane alignment enum for a spatial entity. Corresponding list structure is slink:XrSpatialComponentPlaneAlignmentListEXT; Corresponding data structure is elink:XrSpatialPlaneAlignmentEXT"/> + <enum offset="1" extends="XrSpatialComponentTypeEXT" name="XR_SPATIAL_COMPONENT_TYPE_MESH_2D_EXT" comment="Component that provides a 2D mesh for a spatial entity. Corresponding list structure is slink:XrSpatialComponentMesh2DListEXT; Corresponding data structure is slink:XrSpatialMeshDataEXT"/> + <enum offset="2" extends="XrSpatialComponentTypeEXT" name="XR_SPATIAL_COMPONENT_TYPE_POLYGON_2D_EXT" comment="Component that provides a 2D boundary polygon for a spatial entity. Corresponding list structure is slink:XrSpatialComponentPolygon2DListEXT; Corresponding data structure is slink:XrSpatialPolygon2DDataEXT"/> + <enum offset="3" extends="XrSpatialComponentTypeEXT" name="XR_SPATIAL_COMPONENT_TYPE_PLANE_SEMANTIC_LABEL_EXT" comment="Component that provides a semantic label for a plane. Corresponding list structure is slink:XrSpatialComponentPlaneSemanticLabelListEXT; Corresponding data structure is elink:XrSpatialPlaneSemanticLabelEXT"/> + + <type name="XrSpatialPlaneAlignmentEXT"/> + <type name="XrSpatialPlaneSemanticLabelEXT"/> + + <type name="XrSpatialCapabilityConfigurationPlaneTrackingEXT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_PLANE_TRACKING_EXT"/> + <type name="XrSpatialComponentPlaneAlignmentListEXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_PLANE_ALIGNMENT_LIST_EXT"/> + <type name="XrSpatialComponentMesh2DListEXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_MESH_2D_LIST_EXT"/> + <type name="XrSpatialPolygon2DDataEXT"/> + <type name="XrSpatialComponentPolygon2DListEXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_POLYGON_2D_LIST_EXT"/> + <type name="XrSpatialComponentPlaneSemanticLabelListEXT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_PLANE_SEMANTIC_LABEL_LIST_EXT"/> + + </require> + </extension> + + <extension name="XR_EXT_stationary_reference_space" number="743" type="instance" depends="XR_VERSION_1_0+XR_EXT_uuid" supported="openxr"> + <require> + <enum value="1" name="XR_EXT_stationary_reference_space_SPEC_VERSION"/> + <enum value=""XR_EXT_stationary_reference_space"" name="XR_EXT_STATIONARY_REFERENCE_SPACE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrReferenceSpaceType" name="XR_REFERENCE_SPACE_TYPE_STATIONARY_EXT"/> + + <type name="XrStationaryReferenceSpaceGenerationIdGetInfoEXT"/> + <type name="XrStationaryReferenceSpaceGenerationIdResultEXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_STATIONARY_REFERENCE_SPACE_GENERATION_ID_GET_INFO_EXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_STATIONARY_REFERENCE_SPACE_GENERATION_ID_RESULT_EXT"/> + + <command name="xrGetStationaryReferenceSpaceGenerationIdEXT"/> + </require> + </extension> + + <extension name="XR_EXT_spatial_marker_tracking" number="744" type="instance" supported="openxr" depends="XR_EXT_spatial_entity" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_spatial_marker_tracking_SPEC_VERSION"/> + <enum value=""XR_EXT_spatial_marker_tracking"" name="XR_EXT_SPATIAL_MARKER_TRACKING_EXTENSION_NAME"/> + + <enum offset="0" extends="XrSpatialCapabilityEXT" name="XR_SPATIAL_CAPABILITY_MARKER_TRACKING_QR_CODE_EXT" comment="Capability to be able to detect and track QR codes."/> + <enum offset="1" extends="XrSpatialCapabilityEXT" name="XR_SPATIAL_CAPABILITY_MARKER_TRACKING_MICRO_QR_CODE_EXT" comment="Capability to be able to detect and track Micro QR codes."/> + <enum offset="2" extends="XrSpatialCapabilityEXT" name="XR_SPATIAL_CAPABILITY_MARKER_TRACKING_ARUCO_MARKER_EXT" comment="Capability to be able to detect and track Aruco Markers."/> + <enum offset="3" extends="XrSpatialCapabilityEXT" name="XR_SPATIAL_CAPABILITY_MARKER_TRACKING_APRIL_TAG_EXT" comment="Capability to be able to detect and track AprilTags."/> + + <enum offset="0" extends="XrSpatialComponentTypeEXT" name="XR_SPATIAL_COMPONENT_TYPE_MARKER_EXT" comment="A component describing the marker type, id and location. Corresponding list structure is slink:XrSpatialComponentMarkerListEXT; Corresponding data structure is slink:XrSpatialMarkerDataEXT"/> + + <enum offset="0" extends="XrSpatialCapabilityFeatureEXT" name="XR_SPATIAL_CAPABILITY_FEATURE_MARKER_TRACKING_FIXED_SIZE_MARKERS_EXT" comment="Capability feature to allow applications to specify the size for the markers. Corresponding config structure is slink:XrSpatialMarkerSizeEXT"/> + <enum offset="1" extends="XrSpatialCapabilityFeatureEXT" name="XR_SPATIAL_CAPABILITY_FEATURE_MARKER_TRACKING_STATIC_MARKERS_EXT" comment="Capability feature to allow applications to specify if markers are static. Corresponding config structure is slink:XrSpatialMarkerStaticOptimizationEXT"/> + + <!-- enums --> + <type name="XrSpatialMarkerArucoDictEXT"/> + <type name="XrSpatialMarkerAprilTagDictEXT"/> + + <!-- structs --> + <type name="XrSpatialCapabilityConfigurationQrCodeEXT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_QR_CODE_EXT"/> + <type name="XrSpatialCapabilityConfigurationMicroQrCodeEXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_MICRO_QR_CODE_EXT"/> + <type name="XrSpatialCapabilityConfigurationArucoMarkerEXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ARUCO_MARKER_EXT"/> + <type name="XrSpatialCapabilityConfigurationAprilTagEXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_APRIL_TAG_EXT"/> + <type name="XrSpatialMarkerSizeEXT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SPATIAL_MARKER_SIZE_EXT"/> + <type name="XrSpatialMarkerStaticOptimizationEXT"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_SPATIAL_MARKER_STATIC_OPTIMIZATION_EXT"/> + <type name="XrSpatialMarkerDataEXT"/> + <type name="XrSpatialComponentMarkerListEXT"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_MARKER_LIST_EXT"/> + </require> + </extension> + + <extension name="XR_EXT_extension_745" number="745" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_745_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_745"" name="XR_EXT_EXTENSION_745_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_LOGITECH_mx_ink_stylus_interaction" number="746" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_LOGITECH_mx_ink_stylus_interaction_SPEC_VERSION"/> + <enum value=""XR_LOGITECH_mx_ink_stylus_interaction"" name="XR_LOGITECH_MX_INK_STYLUS_INTERACTION_EXTENSION_NAME"/> + <interaction_profile name="/interaction_profiles/logitech/mx_ink_stylus_logitech"/> + </require> + <require depends="XR_EXT_palm_pose"> + <extend interaction_profile_path="/interaction_profiles/logitech/mx_ink_stylus_logitech"> + <component subpath="/input/palm_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + <require depends="XR_EXT_hand_interaction"> + <extend interaction_profile_path="/interaction_profiles/logitech/mx_ink_stylus_logitech"> + <component subpath="/input/pinch_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + <component subpath="/input/poke_ext/pose" type="XR_ACTION_TYPE_POSE_INPUT"/> + </extend> + </require> + </extension> + + <extension name="XR_BD_dynamic_object_tracking" number="747" depends="XR_BD_spatial_sensing" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_dynamic_object_tracking_SPEC_VERSION"/> + <enum value=""XR_BD_dynamic_object_tracking"" name="XR_BD_DYNAMIC_OBJECT_TRACKING_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_DYNAMIC_OBJECT_TRACKING_PROPERTIES_BD"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SENSE_DATA_PROVIDER_CREATE_INFO_DYNAMIC_OBJECT_BD"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_COMPONENT_DATA_DYNAMIC_OBJECT_BD"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_DYNAMIC_OBJECT_DATA_BD"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SENSE_DATA_FILTER_DYNAMIC_OBJECT_TYPE_BD" comment="XrSenseDataFilterDynamicObjectTypeBD"/> + + <enum offset="0" extends="XrSenseDataProviderTypeBD" name="XR_SENSE_DATA_PROVIDER_TYPE_DYNAMIC_OBJECT_BD" comment="Capture dynamic object data."/> + + <enum offset="0" extends="XrSpatialEntityComponentTypeBD" name="XR_SPATIAL_ENTITY_COMPONENT_TYPE_DYNAMIC_OBJECT_BD" comment="The dynamic object component. Corresponds to component data structure slink:XrSpatialEntityComponentDataDynamicObjectBD."/> + + <type name="XrSystemDynamicObjectTrackingPropertiesBD"/> + <type name="XrSenseDataProviderCreateInfoDynamicObjectBD"/> + <type name="XrSpatialEntityComponentDataDynamicObjectBD"/> + <type name="XrDynamicObjectDataBD"/> + <type name="XrSenseDataFilterDynamicObjectTypeBD"/> + <type name="XrDynamicObjectTypeBD"/> + + </require> + </extension> + + <extension name="XR_BD_dynamic_object_keyboard" number="748" depends="XR_BD_dynamic_object_tracking" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_dynamic_object_keyboard_SPEC_VERSION"/> + <enum value=""XR_BD_dynamic_object_keyboard"" name="XR_BD_DYNAMIC_OBJECT_KEYBOARD_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_DYNAMIC_OBJECT_KEYBOARD_PROPERTIES_BD"/> + <enum offset="0" extends="XrDynamicObjectTypeBD" name="XR_DYNAMIC_OBJECT_TYPE_KEYBOARD_BD" comment="Represents a keyboard"/> + + <type name="XrSystemDynamicObjectKeyboardPropertiesBD"/> + + </require> + </extension> + + <extension name="XR_BD_dynamic_object_mouse" number="749" depends="XR_BD_dynamic_object_tracking" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_dynamic_object_mouse_SPEC_VERSION"/> + <enum value=""XR_BD_dynamic_object_mouse"" name="XR_BD_DYNAMIC_OBJECT_MOUSE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_DYNAMIC_OBJECT_MOUSE_PROPERTIES_BD"/> + <enum offset="0" extends="XrDynamicObjectTypeBD" name="XR_DYNAMIC_OBJECT_TYPE_MOUSE_BD" comment="Represents a mouse"/> + + <type name="XrSystemDynamicObjectMousePropertiesBD"/> + + </require> + </extension> + + <extension name="XR_BD_extension_750" number="750" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_750_SPEC_VERSION"/> + <enum value=""XR_BD_extension_750"" name="XR_BD_EXTENSION_750_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_751" number="751" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_751_SPEC_VERSION"/> + <enum value=""XR_BD_extension_751"" name="XR_BD_EXTENSION_751_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_752" number="752" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_752_SPEC_VERSION"/> + <enum value=""XR_BD_extension_752"" name="XR_BD_EXTENSION_752_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_753" number="753" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_753_SPEC_VERSION"/> + <enum value=""XR_BD_extension_753"" name="XR_BD_EXTENSION_753_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_754" number="754" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_754_SPEC_VERSION"/> + <enum value=""XR_BD_extension_754"" name="XR_BD_EXTENSION_754_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_755" number="755" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_755_SPEC_VERSION"/> + <enum value=""XR_BD_extension_755"" name="XR_BD_EXTENSION_755_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_camera_image" number="756" depends="XR_EXT_future" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_BD_camera_image_SPEC_VERSION"/> + <enum value=""XR_BD_camera_image"" name="XR_BD_CAMERA_IMAGE_EXTENSION_NAME"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_CAMERA_UNAVAILABLE_BD" comment="The camera is not available."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_CAMERA_OCCUPIED_BD" comment="The camera is occupied by other process."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_CAMERA_CAPTURE_SESSION_CAPTURING_BD" comment="The camera capture session is capturing."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_CAMERA_CAPTURE_SESSION_NOT_CAPTURING_BD" comment="The camera capture session is not capturing."/> + <enum offset="4" dir="-" extends="XrResult" name="XR_ERROR_CAMERA_ID_INVALID_BD" comment="The camera ID is not valid."/> + <enum offset="5" dir="-" extends="XrResult" name="XR_ERROR_CAMERA_IMAGE_ID_INVALID_BD" comment="The camera image ID is not valid."/> + <enum offset="6" dir="-" extends="XrResult" name="XR_ERROR_CAMERA_PROPERTY_TYPE_INVALID_BD" comment="The camera property type is not valid."/> + <enum offset="7" dir="-" extends="XrResult" name="XR_ERROR_CAMERA_CAPABILITY_TYPE_INVALID_BD" comment="The camera capability type is not valid."/> + <enum offset="8" dir="-" extends="XrResult" name="XR_ERROR_IMAGE_BUFFER_EXHAUSTED_BD" comment="The image buffer is exhausted."/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_AVAILABLE_CAMERAS_ENUMERATE_INFO_BD"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_CAMERA_PROPERTIES_GET_INFO_BD"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_CAMERA_PROPERTIES_BD"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_CAMERA_PROPERTY_FACING_BD"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_CAMERA_PROPERTY_POSITION_BD"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_CAMERA_PROPERTY_CAMERA_TYPE_BD"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_CAMERA_SUPPORTED_CAPABILITIES_GET_INFO_BD"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_CAMERA_SUPPORTED_CAPABILITIES_BD"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_IMAGE_RESOLUTION_AND_FRAME_RATE_BD"/> + <enum offset="9" extends="XrStructureType" name="XR_TYPE_CAMERA_CAPABILITY_IMAGE_RESOLUTION_AND_FRAME_RATE_BD"/> + <enum offset="10" extends="XrStructureType" name="XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_DATA_TRANSFER_TYPE_BD"/> + <enum offset="11" extends="XrStructureType" name="XR_TYPE_CAMERA_CAPABILITY_DATA_TRANSFER_TYPE_BD"/> + <enum offset="12" extends="XrStructureType" name="XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_IMAGE_FORMAT_BD"/> + <enum offset="13" extends="XrStructureType" name="XR_TYPE_CAMERA_CAPABILITY_IMAGE_FORMAT_BD"/> + <enum offset="14" extends="XrStructureType" name="XR_TYPE_CAMERA_SUPPORTED_CAPABILITY_CAMERA_MODEL_BD"/> + <enum offset="15" extends="XrStructureType" name="XR_TYPE_CAMERA_CAPABILITY_CAMERA_MODEL_BD"/> + <enum offset="16" extends="XrStructureType" name="XR_TYPE_CAMERA_DEVICE_CREATE_INFO_BD"/> + <enum offset="17" extends="XrStructureType" name="XR_TYPE_CREATE_CAMERA_DEVICE_COMPLETION_BD"/> + <enum offset="18" extends="XrStructureType" name="XR_TYPE_CAMERA_CAPTURE_SESSION_CREATE_INFO_BD"/> + <enum offset="19" extends="XrStructureType" name="XR_TYPE_CREATE_CAMERA_CAPTURE_SESSION_COMPLETION_BD"/> + <enum offset="20" extends="XrStructureType" name="XR_TYPE_CAMERA_INTRINSICS_BD"/> + <enum offset="21" extends="XrStructureType" name="XR_TYPE_CAMERA_EXTRINSICS_BD"/> + <enum offset="22" extends="XrStructureType" name="XR_TYPE_CAMERA_CAPTURE_BEGIN_INFO_BD"/> + <enum offset="23" extends="XrStructureType" name="XR_TYPE_CAMERA_IMAGE_ACQUIRE_INFO_BD"/> + <enum offset="24" extends="XrStructureType" name="XR_TYPE_CAMERA_IMAGE_BD"/> + <enum offset="25" extends="XrStructureType" name="XR_TYPE_CAMERA_IMAGE_DATA_RAW_BUFFER_BD"/> + <enum offset="26" extends="XrStructureType" name="XR_TYPE_CAMERA_CAPABILITIES_BD"/> + <enum offset="27" extends="XrStructureType" name="XR_TYPE_CAMERA_CAPABILITY_TYPES_ENUMERATE_INFO_BD"/> + <enum offset="28" extends="XrStructureType" name="XR_TYPE_CAMERA_CAPABILITY_TYPES_BD"/> + <enum offset="29" extends="XrStructureType" name="XR_TYPE_CAMERA_PROPERTY_TYPES_ENUMERATE_INFO_BD"/> + <enum offset="30" extends="XrStructureType" name="XR_TYPE_CAMERA_PROPERTY_TYPES_BD"/> + <enum offset="31" extends="XrStructureType" name="XR_TYPE_AVAILABLE_CAMERA_BD"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_CAMERA_DEVICE_BD" comment="XrCameraDeviceBD"/> + <enum offset="1" extends="XrObjectType" name="XR_OBJECT_TYPE_CAMERA_CAPTURE_SESSION_BD" comment="XrCameraCaptureSessionBD"/> + + <type name="XrCameraIdBD"/> + <type name="XrCameraDeviceBD"/> + <type name="XrCameraCaptureSessionBD"/> + <type name="XrAvailableCamerasEnumerateInfoBD"/> + <type name="XrAvailableCameraBD"/> + <type name="XrCameraPropertyTypeBD"/> + <type name="XrCameraPropertyTypesEnumerateInfoBD"/> + <type name="XrCameraPropertyTypesBD"/> + <type name="XrCameraPropertiesGetInfoBD"/> + <type name="XrCameraPropertiesBD"/> + <type name="XrCameraPropertyBaseHeaderBD"/> + <type name="XrCameraFacingBD"/> + <type name="XrCameraPropertyFacingBD"/> + <type name="XrCameraPositionBD"/> + <type name="XrCameraPropertyPositionBD"/> + <type name="XrCameraTypeBD"/> + <type name="XrCameraPropertyCameraTypeBD"/> + <type name="XrCameraCapabilityTypeBD"/> + <type name="XrCameraCapabilityTypesEnumerateInfoBD"/> + <type name="XrCameraCapabilityTypesBD"/> + <type name="XrCameraSupportedCapabilitiesGetInfoBD"/> + <type name="XrCameraSupportedCapabilityBaseHeaderBD"/> + <type name="XrCameraSupportedCapabilitiesBD"/> + <type name="XrCameraCapabilityBaseHeaderBD"/> + <type name="XrCameraCapabilitiesBD"/> + <type name="XrCameraImageResolutionAndFrameRateBD"/> + <type name="XrCameraSupportedCapabilityImageResolutionAndFrameRateBD"/> + <type name="XrCameraCapabilityImageResolutionAndFrameRateBD"/> + <type name="XrCameraDataTransferTypeBD"/> + <type name="XrCameraSupportedCapabilityDataTransferTypeBD"/> + <type name="XrCameraCapabilityDataTransferTypeBD"/> + <type name="XrCameraImageFormatBD"/> + <type name="XrCameraSupportedCapabilityImageFormatBD"/> + <type name="XrCameraCapabilityImageFormatBD"/> + <type name="XrCameraModelBD"/> + <type name="XrCameraSupportedCapabilityCameraModelBD"/> + <type name="XrCameraCapabilityCameraModelBD"/> + <type name="XrCameraDeviceCreateInfoBD"/> + <type name="XrCreateCameraDeviceCompletionBD"/> + <type name="XrCameraCaptureSessionCreateInfoBD"/> + <type name="XrCreateCameraCaptureSessionCompletionBD"/> + <type name="XrCameraIntrinsicsBD"/> + <type name="XrCameraExtrinsicsBD"/> + <type name="XrCameraCaptureBeginInfoBD"/> + <type name="XrCameraImageAcquireInfoBD"/> + <type name="XrCameraImageIdBD"/> + <type name="XrCameraImageBD"/> + <type name="XrCameraImageDataBaseHeaderBD"/> + <type name="XrCameraImageDataRawBufferBD"/> + + <command name="xrEnumerateAvailableCamerasBD"/> + <command name="xrEnumerateCameraPropertyTypesBD"/> + + <command name="xrGetCameraPropertiesBD"/> + <command name="xrEnumerateCameraCapabilityTypesBD"/> + <command name="xrGetCameraSupportedCapabilitiesBD"/> + <command name="xrCreateCameraDeviceAsyncBD"/> + <command name="xrCreateCameraDeviceCompleteBD"/> + <command name="xrDestroyCameraDeviceBD"/> + <command name="xrCreateCameraCaptureSessionAsyncBD"/> + <command name="xrCreateCameraCaptureSessionCompleteBD"/> + <command name="xrDestroyCameraCaptureSessionBD"/> + <command name="xrBeginCameraCaptureBD"/> + <command name="xrEndCameraCaptureBD"/> + <command name="xrAcquireCameraImageBD"/> + <command name="xrGetCameraImageDataBD"/> + <command name="xrReleaseCameraImageBD"/> + </require> + </extension> + + <extension name="XR_BD_extension_757" number="757" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_757_SPEC_VERSION"/> + <enum value=""XR_BD_extension_757"" name="XR_BD_EXTENSION_757_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_758" number="758" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_758_SPEC_VERSION"/> + <enum value=""XR_BD_extension_758"" name="XR_BD_EXTENSION_758_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_759" number="759" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_759_SPEC_VERSION"/> + <enum value=""XR_BD_extension_759"" name="XR_BD_EXTENSION_759_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_760" number="760" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_760_SPEC_VERSION"/> + <enum value=""XR_BD_extension_760"" name="XR_BD_EXTENSION_760_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_BD_extension_761" number="761" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_BD_extension_761_SPEC_VERSION"/> + <enum value=""XR_BD_extension_761"" name="XR_BD_EXTENSION_761_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_spatial_discovery_bounds" number="762" type="instance" supported="openxr" depends="XR_EXT_spatial_entity"> + <require> + <enum value="1" name="XR_ANDROID_spatial_discovery_bounds_SPEC_VERSION"/> + <enum value=""XR_ANDROID_spatial_discovery_bounds"" name="XR_ANDROID_SPATIAL_DISCOVERY_BOUNDS_EXTENSION_NAME"/> + + <enum offset="0" extends="XrSpatialCapabilityFeatureEXT" name="XR_SPATIAL_CAPABILITY_FEATURE_SPHERE_BOUNDS_FILTER_ANDROID" comment="The runtime supports slink:XrSpatialBoundsSpherefANDROID filter for slink:XrSpatialDiscoverySnapshotCreateInfoEXT; This does not require any configuration structure to be included during spatial context creation."/> + <enum offset="1" extends="XrSpatialCapabilityFeatureEXT" name="XR_SPATIAL_CAPABILITY_FEATURE_BOX_BOUNDS_FILTER_ANDROID" comment="The runtime supports slink:XrSpatialBoundsBoxfANDROID filter for slink:XrSpatialDiscoverySnapshotCreateInfoEXT; This does not require any configuration structure to be included during spatial context creation."/> + <enum offset="2" extends="XrSpatialCapabilityFeatureEXT" name="XR_SPATIAL_CAPABILITY_FEATURE_FRUSTUM_BOUNDS_FILTER_ANDROID" comment="The runtime supports slink:XrSpatialBoundsFrustumfANDROID filter for slink:XrSpatialDiscoverySnapshotCreateInfoEXT; This does not require any configuration structure to be included during spatial context creation."/> + + <type name="XrSpatialBoundsSpherefANDROID"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_BOUNDS_SPHEREF_ANDROID"/> + <type name="XrSpatialBoundsBoxfANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_BOUNDS_BOXF_ANDROID"/> + <type name="XrSpatialBoundsFrustumfANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_BOUNDS_FRUSTUMF_ANDROID"/> + </require> + </extension> + + <extension name="XR_EXT_spatial_anchor" number="763" type="instance" supported="openxr" depends="XR_EXT_spatial_entity" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_spatial_anchor_SPEC_VERSION"/> + <enum value=""XR_EXT_spatial_anchor"" name="XR_EXT_SPATIAL_ANCHOR_EXTENSION_NAME"/> + + <enum offset="0" extends="XrSpatialCapabilityEXT" name="XR_SPATIAL_CAPABILITY_ANCHOR_EXT" comment="Capability to be able to create spatial anchors"/> + + <enum offset="0" extends="XrSpatialComponentTypeEXT" name="XR_SPATIAL_COMPONENT_TYPE_ANCHOR_EXT" comment="Component that provides the location for an anchor. Corresponding list structure is slink:XrSpatialComponentAnchorListEXT; Corresponding data structure is slink:XrPosef"/> + + <type name="XrSpatialCapabilityConfigurationAnchorEXT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_ANCHOR_EXT"/> + <type name="XrSpatialComponentAnchorListEXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_ANCHOR_LIST_EXT"/> + <type name="XrSpatialAnchorCreateInfoEXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_CREATE_INFO_EXT"/> + + <command name="xrCreateSpatialAnchorEXT"/> + </require> + </extension> + + <extension name="XR_EXT_spatial_persistence" number="764" type="instance" supported="openxr" depends="XR_EXT_spatial_entity+XR_EXT_future" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_spatial_persistence_SPEC_VERSION"/> + <enum value=""XR_EXT_spatial_persistence"" name="XR_EXT_SPATIAL_PERSISTENCE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrSpatialComponentTypeEXT" name="XR_SPATIAL_COMPONENT_TYPE_PERSISTENCE_EXT" comment="Component that provides the persisted UUID for a spatial entity. Corresponding list structure is slink:XrSpatialComponentPersistenceListEXT; Corresponding data structure is slink:XrSpatialPersistenceDataEXT"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SPATIAL_PERSISTENCE_CONTEXT_EXT" comment="XrSpatialPersistenceContextEXT"/> + + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_PERSISTENCE_SCOPE_UNSUPPORTED_EXT" comment="The specified spatial persistence scope is not supported by the runtime or the system."/> + + <type name="XrSpatialPersistenceContextEXT"/> + + <type name="XrSpatialPersistenceScopeEXT"/> + <type name="XrSpatialPersistenceContextResultEXT"/> + <type name="XrSpatialPersistenceStateEXT"/> + + <type name="XrSpatialPersistenceContextCreateInfoEXT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_PERSISTENCE_CONTEXT_CREATE_INFO_EXT"/> + <type name="XrCreateSpatialPersistenceContextCompletionEXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_CREATE_SPATIAL_PERSISTENCE_CONTEXT_COMPLETION_EXT"/> + <type name="XrSpatialContextPersistenceConfigEXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_CONTEXT_PERSISTENCE_CONFIG_EXT"/> + <type name="XrSpatialDiscoveryPersistenceUuidFilterEXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPATIAL_DISCOVERY_PERSISTENCE_UUID_FILTER_EXT"/> + <type name="XrSpatialPersistenceDataEXT"/> + <type name="XrSpatialComponentPersistenceListEXT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_PERSISTENCE_LIST_EXT"/> + + <command name="xrEnumerateSpatialPersistenceScopesEXT"/> + <command name="xrCreateSpatialPersistenceContextAsyncEXT"/> + <command name="xrCreateSpatialPersistenceContextCompleteEXT"/> + <command name="xrDestroySpatialPersistenceContextEXT"/> + </require> + </extension> + + <extension name="XR_EPIC_extension_765" number="765" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EPIC_extension_765_SPEC_VERSION"/> + <enum value=""XR_EPIC_extension_765"" name="XR_EPIC_extension_765_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EPIC_extension_766" number="766" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EPIC_extension_766_SPEC_VERSION"/> + <enum value=""XR_EPIC_extension_766"" name="XR_EPIC_extension_766_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EPIC_extension_767" number="767" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EPIC_extension_767_SPEC_VERSION"/> + <enum value=""XR_EPIC_extension_767"" name="XR_EPIC_extension_767_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EPIC_extension_768" number="768" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EPIC_extension_768_SPEC_VERSION"/> + <enum value=""XR_EPIC_extension_768"" name="XR_EPIC_extension_768_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EPIC_extension_769" number="769" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EPIC_extension_769_SPEC_VERSION"/> + <enum value=""XR_EPIC_extension_769"" name="XR_EPIC_extension_769_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EPIC_extension_770" number="770" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EPIC_extension_770_SPEC_VERSION"/> + <enum value=""XR_EPIC_extension_770"" name="XR_EPIC_extension_770_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EPIC_extension_771" number="771" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EPIC_extension_771_SPEC_VERSION"/> + <enum value=""XR_EPIC_extension_771"" name="XR_EPIC_extension_771_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EPIC_extension_772" number="772" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EPIC_extension_772_SPEC_VERSION"/> + <enum value=""XR_EPIC_extension_772"" name="XR_EPIC_extension_772_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EPIC_extension_773" number="773" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EPIC_extension_773_SPEC_VERSION"/> + <enum value=""XR_EPIC_extension_773"" name="XR_EPIC_extension_773_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EPIC_extension_774" number="774" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EPIC_extension_774_SPEC_VERSION"/> + <enum value=""XR_EPIC_extension_774"" name="XR_EPIC_extension_774_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_KHR_hand_tracking" number="775" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_KHR_hand_tracking_SPEC_VERSION"/> + <enum value=""XR_KHR_hand_tracking"" name="XR_KHR_HAND_TRACKING_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_haptic_parametric" number="776" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_EXT_haptic_parametric_SPEC_VERSION"/> + <enum value=""XR_EXT_haptic_parametric"" name="XR_EXT_HAPTIC_PARAMETRIC_EXTENSION_NAME"/> + + <type name="XR_HAPTIC_PARAMETRIC_MAX_POINTS_TRANSIENTS_EXT"/> + <type name="XR_HAPTIC_PARAMETRIC_VIBRATION_EXTEND_DURATION_EXT"/> + <type name="XR_HAPTIC_PARAMETRIC_FREQUENCY_MIN_HZ_EXT"/> + <type name="XR_HAPTIC_PARAMETRIC_FREQUENCY_MAX_HZ_EXT"/> + <type name="XrHapticParametricPropertiesEXT"/> + <type name="XrHapticParametricPointEXT"/> + <type name="XrHapticParametricTransientEXT"/> + <type name="XrHapticParametricVibrationEXT"/> + <type name="XrHapticParametricStreamFrameTypeEXT"/> + <type name="XrSystemHapticParametricPropertiesEXT"/> + + <command name="xrHapticParametricGetPropertiesEXT"/> + + <extend type="command" name="xrApplyHapticFeedback" errorcodes="XR_ERROR_FEATURE_UNSUPPORTED"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_HAPTIC_PARAMETRIC_VIBRATION_EXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_HAPTIC_PARAMETRIC_PROPERTIES_EXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SYSTEM_HAPTIC_PARAMETRIC_PROPERTIES_EXT"/> + </require> + </extension> + + <extension name="XR_SONY_swapchain_color_space" number="777" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_SONY_swapchain_color_space_SPEC_VERSION"/> + <enum value=""XR_SONY_swapchain_color_space"" name="XR_SONY_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_COLOR_SPACES_ENUMERATE_INFO_SONY"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SWAPCHAIN_CREATE_INFO_COLOR_SPACE_SONY"/> + + <type name="XrColorSpaceSONY"/> + <type name="XrColorSpacesEnumerateInfoSONY"/> + <type name="XrSwapchainCreateInfoColorSpaceSONY"/> + + <command name="xrEnumerateColorSpacesSONY"/> + </require> + </extension> + + <extension name="XR_SONY_hdr_metadata" number="778" type="instance" supported="openxr" depends="XR_SONY_swapchain_color_space"> + <require> + <enum value="1" name="XR_SONY_hdr_metadata_SPEC_VERSION"/> + <enum value=""XR_SONY_hdr_metadata"" name="XR_SONY_HDR_METADATA_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_HDR_METADATA_SONY"/> + + <type name="XrHdrMetadataSONY"/> + <type name="XrXYColorSONY"/> + + <command name="xrSetHdrMetadataSONY"/> + </require> + </extension> + + <extension name="XR_SONY_extension_779" number="779" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_SONY_extension_779_SPEC_VERSION"/> + <enum value=""XR_SONY_extension_779"" name="XR_SONY_EXTENSION_779_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_SONY_extension_780" number="780" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_SONY_extension_780_SPEC_VERSION"/> + <enum value=""XR_SONY_extension_780"" name="XR_SONY_EXTENSION_780_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_SONY_extension_781" number="781" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_SONY_extension_781_SPEC_VERSION"/> + <enum value=""XR_SONY_extension_781"" name="XR_SONY_EXTENSION_781_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_spatial_persistence_operations" number="782" type="instance" supported="openxr" depends="XR_EXT_spatial_persistence+XR_EXT_future" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_spatial_persistence_operations_SPEC_VERSION"/> + <enum value=""XR_EXT_spatial_persistence_operations"" name="XR_EXT_SPATIAL_PERSISTENCE_OPERATIONS_EXTENSION_NAME"/> + + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_PERSISTENCE_SCOPE_INCOMPATIBLE_EXT" comment="The scope configured for the persistence context is incompatible for the current spatial entity."/> + + <enum offset="0" extends="XrSpatialPersistenceScopeEXT" name="XR_SPATIAL_PERSISTENCE_SCOPE_LOCAL_ANCHORS_EXT" comment="Persistence operations and data access is limited to spatial anchors, on the same device, for the same user and same app"/> + + <enum offset="1" dir="-" extends="XrSpatialPersistenceContextResultEXT" name="XR_SPATIAL_PERSISTENCE_CONTEXT_RESULT_ENTITY_NOT_TRACKING_EXT" comment="The persistence operation failed because the entity could not be tracked by the runtime."/> + <enum offset="2" dir="-" extends="XrSpatialPersistenceContextResultEXT" name="XR_SPATIAL_PERSISTENCE_CONTEXT_RESULT_PERSIST_UUID_NOT_FOUND_EXT" comment="The provided persist UUID was not found in the storage."/> + + <type name="XrSpatialEntityPersistInfoEXT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_PERSIST_INFO_EXT"/> + <type name="XrPersistSpatialEntityCompletionEXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_PERSIST_SPATIAL_ENTITY_COMPLETION_EXT"/> + <type name="XrSpatialEntityUnpersistInfoEXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_ENTITY_UNPERSIST_INFO_EXT"/> + <type name="XrUnpersistSpatialEntityCompletionEXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_UNPERSIST_SPATIAL_ENTITY_COMPLETION_EXT"/> + + <command name="xrPersistSpatialEntityAsyncEXT"/> + <command name="xrPersistSpatialEntityCompleteEXT"/> + <command name="xrUnpersistSpatialEntityAsyncEXT"/> + <command name="xrUnpersistSpatialEntityCompleteEXT"/> + </require> + </extension> + + <extension name="XR_EXT_spatial_image_tracking" number="783" type="instance" supported="openxr" ratified="openxr" depends="XR_EXT_spatial_entity+XR_EXT_future"> + <require> + <enum value="1" name="XR_EXT_spatial_image_tracking_SPEC_VERSION"/> + <enum value=""XR_EXT_spatial_image_tracking"" name="XR_EXT_SPATIAL_IMAGE_TRACKING_EXTENSION_NAME"/> + + <type name="XrSpatialImageTrackingDatabaseEXT"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SPATIAL_IMAGE_TRACKING_DATABASE_EXT" comment="XrSpatialImageTrackingDatabaseEXT"/> + + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_IMAGE_FORMAT_UNSUPPORTED_EXT" comment="A format has been passed that is not supported by the runtime."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_IMAGE_INVALID_EXT" comment="The data of an input image could not be evaluated successfully according to its input format and planes."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_IMAGE_SIZE_MISSING_EXT" comment="An input image that requires a slink:XrSpatialImageSizeEXT structure has not been provided with one."/> + + <type name="XrSpatialReferenceImageFormatEXT"/> + + <type name="XrSpatialReferenceImagePlaneEXT"/> + <type name="XrSpatialReferenceImageEXT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_REFERENCE_IMAGE_EXT"/> + <type name="XrSpatialImageStaticOptimizationEXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_IMAGE_STATIC_OPTIMIZATION_EXT"/> + <type name="XrSpatialImageSizeEXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_IMAGE_SIZE_EXT"/> + <type name="XrSpatialCapabilityConfigurationImageTrackingEXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_IMAGE_TRACKING_EXT"/> + <type name="XrSpatialImageTrackingDatabaseCreateInfoEXT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SPATIAL_IMAGE_TRACKING_DATABASE_CREATE_INFO_EXT"/> + <type name="XrSpatialImage2DDataEXT"/> + <type name="XrSpatialComponentImage2DListEXT"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_IMAGE_2D_LIST_EXT"/> + <type name="XrCreateSpatialImageTrackingDatabaseCompletionEXT"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_CREATE_SPATIAL_IMAGE_TRACKING_DATABASE_COMPLETION_EXT"/> + + <enum offset="0" extends="XrSpatialCapabilityEXT" name="XR_SPATIAL_CAPABILITY_IMAGE_TRACKING_EXT" comment="Capability to be able to detect and track planar reference images."/> + + <enum offset="0" extends="XrSpatialComponentTypeEXT" name="XR_SPATIAL_COMPONENT_TYPE_IMAGE_2D_EXT" comment="A component describing the planar image type. Corresponding list structure is slink:XrSpatialComponentImage2DListEXT. Corresponding data structure is slink:XrSpatialImage2DDataEXT."/> + + <enum offset="0" extends="XrSpatialCapabilityFeatureEXT" name="XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_AUTOMATIC_SIZE_IMAGES_EXT" comment="The runtime supports automatically deducing the physical size of detected and tracked images. Corresponding config structure is slink:XrSpatialImageSizeEXT."/> + <enum offset="1" extends="XrSpatialCapabilityFeatureEXT" name="XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_STATIC_IMAGES_EXT" comment="The runtime supports static image optimization. Corresponding config structure is slink:XrSpatialImageStaticOptimizationEXT."/> + <enum offset="2" extends="XrSpatialCapabilityFeatureEXT" name="XR_SPATIAL_CAPABILITY_FEATURE_IMAGE_TRACKING_FIXED_SIZE_IMAGES_EXT" comment="The runtime supports fixed size images. Corresponding config structure is slink:XrSpatialImageSizeEXT."/> + + <command name="xrEnumerateSpatialReferenceImageFormatsEXT"/> + <command name="xrCreateSpatialImageTrackingDatabaseAsyncEXT"/> + <command name="xrCreateSpatialImageTrackingDatabaseCompleteEXT"/> + <command name="xrDestroySpatialImageTrackingDatabaseEXT"/> + </require> + </extension> + + <extension name="XR_EXT_extension_784" number="784" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_784_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_784"" name="XR_EXT_EXTENSION_784_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_785" number="785" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_785_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_785"" name="XR_EXT_EXTENSION_785_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_spatial_object_tracking" number="786" type="instance" supported="openxr" depends="XR_EXT_spatial_entity"> + <require> + <enum value="2" name="XR_ANDROID_spatial_object_tracking_SPEC_VERSION"/> + <enum value=""XR_ANDROID_spatial_object_tracking"" name="XR_ANDROID_SPATIAL_OBJECT_TRACKING_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_OBJECT_TRACKING_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_OBJECT_SEMANTIC_LABEL_LIST_ANDROID"/> + + <enum offset="0" extends="XrSpatialCapabilityEXT" name="XR_SPATIAL_CAPABILITY_OBJECT_TRACKING_ANDROID" comment="Object tracking"/> + <enum offset="0" extends="XrSpatialComponentTypeEXT" name="XR_SPATIAL_COMPONENT_TYPE_OBJECT_SEMANTIC_LABEL_ANDROID" comment="Component that provides a semantic label for a object; Corresponding list structure is slink:XrSpatialComponentObjectSemanticLabelListANDROID; Corresponding data structure is elink:XrSpatialObjectSemanticLabelANDROID"/> + <type name="XrSpatialObjectSemanticLabelANDROID"/> + <type name="XrSpatialCapabilityConfigurationObjectTrackingANDROID"/> + <type name="XrSpatialComponentObjectSemanticLabelListANDROID"/> + </require> + </extension> + + <!-- XR_ANDROID_spatial_discovery_raycast --> + <extension name="XR_ANDROID_spatial_discovery_raycast" number="787" type="instance" supported="openxr" depends="XR_EXT_spatial_entity"> + <require> + <enum value="1" name="XR_ANDROID_spatial_discovery_raycast_SPEC_VERSION"/> + <enum value=""XR_ANDROID_spatial_discovery_raycast"" name="XR_ANDROID_SPATIAL_DISCOVERY_RAYCAST_EXTENSION_NAME"/> + + <enum offset="0" extends="XrSpatialCapabilityEXT" name="XR_SPATIAL_CAPABILITY_DEPTH_RAYCAST_ANDROID" comment="Raycast against depth buffer"/> + <enum offset="0" extends="XrSpatialComponentTypeEXT" name="XR_SPATIAL_COMPONENT_TYPE_RAYCAST_RESULT_ANDROID" comment="Component that provides the pose of a raycast hit on an entity. Corresponding list structure is slink:XrSpatialComponentRaycastResultListANDROID; Corresponding data structure is slink:XrSpatialRaycastResultDataANDROID"/> + + <type name="XrSpatialRaycastResultDataANDROID"/> + + <type name="XrSpatialCapabilityConfigurationDepthRaycastANDROID"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_CAPABILITY_CONFIGURATION_DEPTH_RAYCAST_ANDROID"/> + <type name="XrSpatialRaycastInfoANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_RAYCAST_INFO_ANDROID"/> + <type name="XrSpatialComponentRaycastResultListANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_RAYCAST_RESULT_LIST_ANDROID"/> + <type name="XrSpatialRaycastSnapshotCreateInfoANDROID"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPATIAL_RAYCAST_SNAPSHOT_CREATE_INFO_ANDROID"/> + + <command name="xrCreateSpatialRaycastSnapshotANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_google_cloud_auth" number="788" type="instance" supported="openxr" depends="XR_EXT_future"> + <require> + <enum value="1" name="XR_ANDROID_google_cloud_auth_SPEC_VERSION"/> + <enum value=""XR_ANDROID_google_cloud_auth"" name="XR_ANDROID_GOOGLE_CLOUD_AUTH_EXTENSION_NAME"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_KEYLESS_AUTH_NOT_SETUP_ANDROID" comment="Keyless auth is not setup properly."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_KEYLESS_AUTH_FAILED_ANDROID" comment="Keyless auth failed. The application can: try again later. The application or developer may: also check certain preconditions for success (e.g. on Android, the device must: have an up-to-date installation of Google Play Services and these services must: be functioning properly)."/> + + <type name="XrGoogleCloudAuthInfoBaseHeaderANDROID"/> + <type name="XrGoogleCloudAuthInfoApiKeyANDROID"/> + <type name="XrGoogleCloudAuthInfoTokenANDROID"/> + <type name="XrGoogleCloudAuthInfoKeylessANDROID"/> + <type name="XrGoogleCloudAuthErrorANDROID"/> + <type name="XrGoogleCloudAuthErrorResultANDROID"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_API_KEY_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_TOKEN_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_GOOGLE_CLOUD_AUTH_INFO_KEYLESS_ANDROID"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_GOOGLE_CLOUD_AUTH_ERROR_RESULT_ANDROID"/> + + <command name="xrSetGoogleCloudAuthAsyncANDROID"/> + <command name="xrSetGoogleCloudAuthCompleteANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_789" number="789" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_789_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_789"" name="XR_ANDROID_EXTENSION_789_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_geospatial" number="790" type="instance" supported="openxr" depends="XR_EXT_future"> + <require> + <enum value="1" name="XR_ANDROID_geospatial_SPEC_VERSION"/> + <enum value=""XR_ANDROID_geospatial"" name="XR_ANDROID_GEOSPATIAL_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SYSTEM_GEOSPATIAL_PROPERTIES_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_GEOSPATIAL_TRACKER_CREATE_INFO_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_GEOSPATIAL_TRACKER_STATE_CHANGED_ANDROID"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_GEOSPATIAL_POSE_FROM_POSE_LOCATE_INFO_ANDROID"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_GEOSPATIAL_POSE_RESULT_ANDROID"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_GEOSPATIAL_POSE_LOCATE_INFO_ANDROID"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_VPS_AVAILABILITY_CHECK_COMPLETION_ANDROID"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_GEOSPATIAL_TRACKER_ANDROID" comment="XrGeospatialTrackerANDROID"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_GEOSPATIAL_TRACKER_NOT_RUNNING_ANDROID" comment="An slink:XrGeospatialTrackerANDROID which is not in ename:XR_GEOSPATIAL_TRACKER_STATE_RUNNING_ANDROID was passed to a function."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_GEOSPATIAL_COORDINATES_INVALID_ANDROID" comment="The supplied geospatial coordinates were invalid."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_GEOSPATIAL_CLOUD_AUTH_FAILED_ANDROID" comment="Cloud auth failed. A structure like slink:XrGoogleCloudAuthErrorResultANDROID in the next chain may: provide more information about the failure."/> + + <type name="XrGeospatialPoseANDROID"/> + <type name="XrSystemGeospatialPropertiesANDROID"/> + <type name="XrGeospatialTrackerANDROID"/> + <type name="XrGeospatialTrackerStateANDROID"/> + <type name="XrGeospatialTrackerCreateInfoANDROID"/> + <type name="XrEventDataGeospatialTrackerStateChangedANDROID"/> + <type name="XrGeospatialPoseFlagsANDROID"/> + <type name="XrGeospatialPoseFlagBitsANDROID"/> + <type name="XrGeospatialPoseFromPoseLocateInfoANDROID"/> + <type name="XrGeospatialPoseResultANDROID"/> + <type name="XrGeospatialPoseLocateInfoANDROID"/> + <type name="XrVPSAvailabilityANDROID"/> + <type name="XrVPSAvailabilityCheckCompletionANDROID"/> + + <command name="xrCreateGeospatialTrackerANDROID"/> + <command name="xrDestroyGeospatialTrackerANDROID"/> + <command name="xrLocateGeospatialPoseFromPoseANDROID"/> + <command name="xrLocateGeospatialPoseANDROID"/> + <command name="xrCheckVpsAvailabilityAsyncANDROID"/> + <command name="xrCheckVpsAvailabilityCompleteANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_spatial_entity_bound_anchor" number="791" type="instance" supported="openxr" depends="XR_EXT_spatial_anchor"> + <require> + <enum value="2" name="XR_ANDROID_spatial_entity_bound_anchor_SPEC_VERSION"/> + <enum value=""XR_ANDROID_spatial_entity_bound_anchor"" name="XR_ANDROID_SPATIAL_ENTITY_BOUND_ANCHOR_EXTENSION_NAME"/> + + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHOR_ATTACHABLE_COMPONENT_NOT_FOUND_ANDROID" comment="Spatial entity with parent ID does not have at least one component enumerated by xrEnumerateSpatialAnchorAttachableComponentsANDROID"/> + + <type name="XrSpatialAnchorParentANDROID"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_PARENT_ANDROID"/> + + <extend type="command" name="xrCreateSpatialAnchorEXT" errorcodes="XR_ERROR_SPATIAL_ANCHOR_ATTACHABLE_COMPONENT_NOT_FOUND_ANDROID,XR_ERROR_SPATIAL_ENTITY_ID_INVALID_EXT"/> + + <command name="xrEnumerateSpatialAnchorAttachableComponentsANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_spatial_component_subsumed_by" number="792" type="instance" supported="openxr" depends="XR_EXT_spatial_entity+XR_EXT_spatial_plane_tracking"> + <require> + <enum value="1" name="XR_ANDROID_spatial_component_subsumed_by_SPEC_VERSION"/> + <enum value=""XR_ANDROID_spatial_component_subsumed_by"" name="XR_ANDROID_SPATIAL_COMPONENT_SUBSUMED_BY_EXTENSION_NAME"/> + + <enum offset="0" extends="XrSpatialComponentTypeEXT" name="XR_SPATIAL_COMPONENT_TYPE_SUBSUMED_BY_ANDROID" comment="Component that provides entity ID of the entity subsuming the attached entity. Corresponding list structure is slink:XrSpatialComponentSubsumedByListANDROID; Corresponding data structure is basetype:XrSpatialEntityIdEXT"/> + <type name="XrSpatialDiscoveryUniqueEntitiesFilterANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_DISCOVERY_UNIQUE_ENTITIES_FILTER_ANDROID"/> + <type name="XrSpatialComponentSubsumedByListANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_COMPONENT_SUBSUMED_BY_LIST_ANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_793" number="793" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_793_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_793"" name="XR_ANDROID_EXTENSION_793_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_794" number="794" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_794_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_794"" name="XR_ANDROID_EXTENSION_794_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_795" number="795" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_795_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_795"" name="XR_ANDROID_EXTENSION_795_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_spatial_anchor_space" number="796" type="instance" supported="openxr" depends="XR_EXT_spatial_anchor"> + <require> + <enum value="1" name="XR_ANDROID_spatial_anchor_space_SPEC_VERSION"/> + <enum value=""XR_ANDROID_spatial_anchor_space"" name="XR_ANDROID_SPATIAL_ANCHOR_SPACE_EXTENSION_NAME"/> + + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_ANCHOR_ENTITY_ID_INVALID_ANDROID" comment="The specified spatial entity ID is invalid for an anchor."/> + + <type name="XrSpatialAnchorSpaceFromIdCreateInfoANDROID"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_ANCHOR_SPACE_FROM_ID_CREATE_INFO_ANDROID"/> + + <command name="xrCreateSpatialAnchorSpaceANDROID"/> + <command name="xrCreateSpatialAnchorSpaceFromIdANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_797" number="797" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_797_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_797"" name="XR_ANDROID_EXTENSION_797_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_geospatial_anchor" number="798" type="instance" supported="openxr" depends="XR_ANDROID_geospatial+XR_EXT_future+XR_EXT_spatial_entity+XR_EXT_spatial_anchor"> + <require> + <enum value="1" name="XR_ANDROID_geospatial_anchor_SPEC_VERSION"/> + <enum value=""XR_ANDROID_geospatial_anchor"" name="XR_ANDROID_GEOSPATIAL_ANCHOR_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_GEOSPATIAL_ANCHOR_CREATE_INFO_ANDROID"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SURFACE_ANCHOR_CREATE_INFO_ANDROID"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SURFACE_ANCHOR_CREATE_COMPLETION_ANDROID"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SYSTEM_GEOSPATIAL_ANCHOR_PROPERTIES_ANDROID"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_GEOSPATIAL_TRACKER_ANCHOR_TRACKING_INFO_ANDROID"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SURFACE_ANCHOR_LOCATION_UNSUPPORTED_ANDROID" comment="There is no surface data for the given location."/> + + <type name="XrSystemGeospatialAnchorPropertiesANDROID"/> + <type name="XrGeospatialTrackerAnchorTrackingInfoANDROID"/> + <type name="XrGeospatialAnchorCreateInfoANDROID"/> + <type name="XrSurfaceAnchorTypeANDROID"/> + <type name="XrSurfaceAnchorCreateInfoANDROID"/> + <type name="XrSurfaceAnchorCreateCompletionANDROID"/> + + <command name="xrCreateGeospatialAnchorANDROID"/> + <command name="xrCreateSurfaceAnchorAsyncANDROID"/> + <command name="xrCreateSurfaceAnchorCompleteANDROID"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_799" number="799" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_799_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_799"" name="XR_ANDROID_EXTENSION_799_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_800" number="800" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_800_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_800"" name="XR_ANDROID_EXTENSION_800_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_801" number="801" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_801_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_801"" name="XR_ANDROID_EXTENSION_801_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_802" number="802" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_802_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_802"" name="XR_ANDROID_EXTENSION_802_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_803" number="803" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_803_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_803"" name="XR_ANDROID_EXTENSION_803_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_804" number="804" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_804_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_804"" name="XR_ANDROID_EXTENSION_804_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_805" number="805" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_805_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_805"" name="XR_ANDROID_EXTENSION_805_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_806" number="806" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_806_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_806"" name="XR_ANDROID_EXTENSION_806_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_807" number="807" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_807_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_807"" name="XR_ANDROID_EXTENSION_807_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_808" number="808" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_808_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_808"" name="XR_ANDROID_EXTENSION_808_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_809" number="809" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_809_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_809"" name="XR_ANDROID_EXTENSION_809_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_810" number="810" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_810_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_810"" name="XR_ANDROID_EXTENSION_810_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_spatial_container" number="811" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_spatial_container_SPEC_VERSION"/> + <enum value=""XR_EXT_spatial_container"" name="XR_EXT_SPATIAL_CONTAINER_EXTENSION_NAME"/> + + <type name="XrSessionCreateInfoSpatialContainersEXT"/> + <type name="XrSpatialContainerEXT"/> + <type name="XrSpatialContainerCreateInfoEXT"/> + <type name="XrSpatialContainerSpaceCreateInfoEXT"/> + <type name="XrEventDataSpatialContainerClosedEXT"/> + <type name="XrSystemSpatialContainerPropertiesEXT"/> + <type name="XrSpatialContainerBoundsEXT"/> + <type name="XrEventDataSpatialContainerBoundsChangedEXT"/> + <type name="XrSpatialContainerBoundsGetInfoEXT"/> + <type name="XrSpatialContainerStateGetInfoEXT"/> + <type name="XrSpatialContainerGraphicsPresentationEXT"/> + <type name="XrSpatialContainerVisibleRequestInfoEXT"/> + <type name="XrEventDataSpatialContainerVisibleChangedEXT"/> + <type name="XrEventDataSpatialContainerVisibleRequestDeniedEXT"/> + <type name="XrEventDataSpatialContainerInteractableChangedEXT"/> + <type name="XrSpatialContainerBoundsModeEXT"/> + <type name="XrSpatialContainerBoundsModeRequestInfoEXT"/> + <type name="XrEventDataSpatialContainerBoundsModeRequestDeniedEXT"/> + <type name="XrSpatialContainerVolumeClippingEXT"/> + <type name="XrSpatialContainerStateEXT"/> + + <enum offset="0" extends="XrObjectType" name="XR_OBJECT_TYPE_SPATIAL_CONTAINER_EXT" comment="XrSpatialContainerEXT"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_CONTAINER_CREATE_INFO_EXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_CONTAINER_SPACE_CREATE_INFO_EXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_CLOSED_EXT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SYSTEM_SPATIAL_CONTAINER_PROPERTIES_EXT"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_SPATIAL_CONTAINER_BOUNDS_EXT"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_BOUNDS_CHANGED_EXT"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_SPATIAL_CONTAINER_BOUNDS_GET_INFO_EXT"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_SPATIAL_CONTAINER_STATE_GET_INFO_EXT"/> + <enum offset="9" extends="XrStructureType" name="XR_TYPE_SPATIAL_CONTAINER_VISIBLE_REQUEST_INFO_EXT"/> + <enum offset="10" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_VISIBLE_CHANGED_EXT"/> + <enum offset="11" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_VISIBLE_REQUEST_DENIED_EXT"/> + <enum offset="12" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_INTERACTABLE_CHANGED_EXT"/> + <enum offset="13" extends="XrStructureType" name="XR_TYPE_SPATIAL_CONTAINER_BOUNDS_MODE_REQUEST_INFO_EXT"/> + <enum offset="14" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_SPATIAL_CONTAINER_BOUNDS_MODE_REQUEST_DENIED_EXT"/> + <enum offset="15" extends="XrStructureType" name="XR_TYPE_SPATIAL_CONTAINER_STATE_EXT"/> + <enum offset="16" extends="XrStructureType" name="XR_TYPE_SESSION_CREATE_INFO_SPATIAL_CONTAINERS_EXT"/> + + <enum offset="0" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_CONTAINER_CLOSED_EXT" comment="The spatial container passed was closed by the runtime."/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_CONTAINERS_ENABLED_EXT" comment="The requested operation is not supported with spatial containers enabled."/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_CONTAINERS_NOT_ENABLED_EXT" comment="The requested operation requires spatial containers be enabled for this slink:XrSession."/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_COMPATIBLE_SPATIAL_CONTAINER_MISSING_EXT" comment="A compatible spatial container was not passed to a function."/> + + <command name="xrCreateSpatialContainerEXT"/> + <command name="xrDestroySpatialContainerEXT"/> + <command name="xrCreateSpatialContainerSpaceEXT"/> + <command name="xrRequestSpatialContainerVisibleEXT"/> + <command name="xrRequestSpatialContainerBoundsModeEXT"/> + <command name="xrGetSpatialContainerBoundsEXT"/> + <command name="xrGetSpatialContainerStateEXT"/> + <command name="xrEnumerateSupportedSpatialContainerGraphicsPresentationsEXT"/> + + <extend type="command" name="xrBeginSession" errorcodes="XR_ERROR_SPATIAL_CONTAINERS_ENABLED_EXT"/> + <extend type="command" name="xrEndSession" errorcodes="XR_ERROR_SPATIAL_CONTAINERS_ENABLED_EXT"/> + <extend type="command" name="xrRequestExitSession" errorcodes="XR_ERROR_SPATIAL_CONTAINERS_ENABLED_EXT"/> + <extend type="command" name="xrLocateViews" errorcodes="XR_ERROR_SPATIAL_CONTAINERS_ENABLED_EXT"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_812" number="812" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_812_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_812"" name="XR_ANDROID_EXTENSION_812_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_813" number="813" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_813_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_813"" name="XR_ANDROID_EXTENSION_813_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_spatial_container_self_rendering" number="814" type="instance" supported="openxr" ratified="openxr" depends="XR_EXT_spatial_container"> + <require> + <enum value="1" name="XR_EXT_spatial_container_self_rendering_SPEC_VERSION"/> + <enum value=""XR_EXT_spatial_container_self_rendering"" name="XR_EXT_SPATIAL_CONTAINER_SELF_RENDERING_EXTENSION_NAME"/> + + <type name="XrSpatialContainerViewLocateInfoEXT"/> + <type name="XrSpatialContainerViewsLocateInfoEXT"/> + <type name="XrSpatialContainerViewStateEXT"/> + <type name="XrSpatialContainerLayerEXT"/> + <type name="XrSpatialContainerLayerFrameEndInfoEXT"/> + <type name="XrSpatialContainerBeginInfoEXT"/> + <type name="XrSpatialContainerEndInfoEXT"/> + <type name="XrSpatialContainerCompositionLayerViewConfigurationEXT"/> + <type name="XrSpatialContainerLayerVolumeClippingEXT"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_SPATIAL_CONTAINER_VIEW_LOCATE_INFO_EXT"/> + <enum offset="1" extends="XrStructureType" name="XR_TYPE_SPATIAL_CONTAINER_VIEWS_LOCATE_INFO_EXT"/> + <enum offset="2" extends="XrStructureType" name="XR_TYPE_SPATIAL_CONTAINER_VIEW_STATE_EXT"/> + <enum offset="3" extends="XrStructureType" name="XR_TYPE_SPATIAL_CONTAINER_LAYER_EXT"/> + <enum offset="4" extends="XrStructureType" name="XR_TYPE_SPATIAL_CONTAINER_LAYER_FRAME_END_INFO_EXT"/> + <enum offset="5" extends="XrStructureType" name="XR_TYPE_SPATIAL_CONTAINER_BEGIN_INFO_EXT"/> + <enum offset="6" extends="XrStructureType" name="XR_TYPE_SPATIAL_CONTAINER_COMPOSITION_LAYER_VIEW_CONFIGURATION_EXT"/> + <enum offset="7" extends="XrStructureType" name="XR_TYPE_SPATIAL_CONTAINER_END_INFO_EXT"/> + <enum offset="8" extends="XrStructureType" name="XR_TYPE_SPATIAL_CONTAINER_LAYER_VOLUME_CLIPPING_EXT"/> + <enum offset="0" extends="XrSpatialContainerGraphicsPresentationEXT" name="XR_SPATIAL_CONTAINER_GRAPHICS_PRESENTATION_SELF_RENDERING_EXT" comment="Spatial container uses OpenXR composition layers"/> + <enum offset="1" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_CONTAINER_IS_RENDERING_EXT" comment="The spatial container is already in the active render set"/> + <enum offset="2" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_CONTAINER_NOT_RENDERING_EXT" comment="The spatial container is not in the active render set"/> + <enum offset="3" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_CONTAINER_MISSING_EXT" comment="A spatial container from the active render set is missing from the submission"/> + <enum offset="4" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_CONTAINER_DUPLICATE_EXT" comment="A spatial container is duplicated in the submission"/> + <enum offset="5" dir="-" extends="XrResult" name="XR_ERROR_SPATIAL_CONTAINER_GRAPHICS_PRESENTATION_MISSING_EXT" comment="The spatial container does not have the required graphics presentation style"/> + + <command name="xrBeginSpatialContainerRenderingEXT"/> + <command name="xrEndSpatialContainerRenderingEXT"/> + <command name="xrLocateSpatialContainerViewsEXT"/> + + <extend type="command" name="xrEndFrame" errorcodes="XR_ERROR_SPATIAL_CONTAINER_DUPLICATE_EXT,XR_ERROR_SPATIAL_CONTAINER_MISSING_EXT,XR_ERROR_SPATIAL_CONTAINER_NOT_RENDERING_EXT"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_815" number="815" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_815_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_815"" name="XR_ANDROID_EXTENSION_815_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_816" number="816" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_816_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_816"" name="XR_ANDROID_EXTENSION_816_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_817" number="817" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_817_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_817"" name="XR_ANDROID_EXTENSION_817_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_818" number="818" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_818_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_818"" name="XR_ANDROID_EXTENSION_818_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_819" number="819" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_819_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_819"" name="XR_ANDROID_EXTENSION_819_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_820" number="820" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_820_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_820"" name="XR_ANDROID_EXTENSION_820_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_821" number="821" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_821_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_821"" name="XR_ANDROID_EXTENSION_821_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_822" number="822" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_822_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_822"" name="XR_ANDROID_EXTENSION_822_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_823" number="823" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_823_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_823"" name="XR_ANDROID_EXTENSION_823_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_824" number="824" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_824_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_824"" name="XR_ANDROID_EXTENSION_824_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_825" number="825" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_825_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_825"" name="XR_ANDROID_EXTENSION_825_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_826" number="826" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_826_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_826"" name="XR_ANDROID_EXTENSION_826_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_827" number="827" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_827_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_827"" name="XR_ANDROID_EXTENSION_827_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_828" number="828" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_828_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_828"" name="XR_ANDROID_EXTENSION_828_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_829" number="829" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_829_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_829"" name="XR_ANDROID_EXTENSION_829_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_830" number="830" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_830_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_830"" name="XR_ANDROID_EXTENSION_830_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_831" number="831" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_831_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_831"" name="XR_ANDROID_EXTENSION_831_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_832" number="832" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_832_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_832"" name="XR_ANDROID_EXTENSION_832_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_833" number="833" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_833_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_833"" name="XR_ANDROID_EXTENSION_833_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_834" number="834" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_834_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_834"" name="XR_ANDROID_EXTENSION_834_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_835" number="835" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_835_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_835"" name="XR_ANDROID_EXTENSION_835_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_836" number="836" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_836_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_836"" name="XR_EXT_EXTENSION_836_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_interaction_profile_battery_state_display" number="837" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="1" name="XR_EXT_interaction_profile_battery_state_display_SPEC_VERSION"/> + <enum value=""XR_EXT_interaction_profile_battery_state_display"" name="XR_EXT_INTERACTION_PROFILE_BATTERY_STATE_DISPLAY_EXTENSION_NAME"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_BATTERY_STATE_DISPLAY_EXT"/> + + <type name="XrBatteryStateDisplayEXT"/> + <type name="XrBatteryStateDisplayStateFlagsEXT"/> + <type name="XrBatteryStateDisplayStateFlagBitsEXT"/> + </require> + </extension> + + <extension name="XR_KHR_extension_838" number="838" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_KHR_extension_838_SPEC_VERSION"/> + <enum value=""XR_KHR_extension_838"" name="XR_KHR_EXTENSION_838_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_loader_init_properties" number="839" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_EXT_loader_init_properties_SPEC_VERSION"/> + <enum value=""XR_EXT_loader_init_properties"" name="XR_EXT_LOADER_INIT_PROPERTIES_EXTENSION_NAME"/> + <type name="XrLoaderInitInfoPropertiesEXT"/> + <type name="XrLoaderInitPropertyValueEXT"/> + <enum offset="0" extends="XrStructureType" name="XR_TYPE_LOADER_INIT_INFO_PROPERTIES_EXT"/> + </require> + </extension> + + <extension name="XR_EXT_view_configuration_views_change" number="840" type="instance" supported="openxr"> + <require> + <enum value="1" name="XR_EXT_view_configuration_views_change_SPEC_VERSION"/> + <enum value=""XR_EXT_view_configuration_views_change"" name="XR_EXT_VIEW_CONFIGURATION_VIEWS_CHANGE_EXTENSION_NAME"/> + + <type name="XrEventDataViewConfigurationViewsChangedEXT"/> + + <enum offset="0" extends="XrStructureType" name="XR_TYPE_EVENT_DATA_VIEW_CONFIGURATION_VIEWS_CHANGED_EXT"/> + </require> + </extension> + + <extension name="XR_KHR_extension_841" number="841" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_KHR_extension_841_SPEC_VERSION"/> + <enum value=""XR_KHR_extension_841"" name="XR_KHR_EXTENSION_841_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_842" number="842" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_842_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_842"" name="XR_EXT_EXTENSION_842_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_843" number="843" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_843_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_843"" name="XR_EXT_EXTENSION_843_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_844" number="844" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_844_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_844"" name="XR_EXT_EXTENSION_844_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_845" number="845" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_845_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_845"" name="XR_EXT_EXTENSION_845_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_846" number="846" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_846_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_846"" name="XR_EXT_EXTENSION_846_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_847" number="847" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_847_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_847"" name="XR_EXT_EXTENSION_847_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_848" number="848" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_848_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_848"" name="XR_EXT_EXTENSION_848_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_849" number="849" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_849_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_849"" name="XR_EXT_EXTENSION_849_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_850" number="850" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_850_SPEC_VERSION"/> + <enum value=""XR_NV_extension_850"" name="XR_NV_EXTENSION_850_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_851" number="851" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_851_SPEC_VERSION"/> + <enum value=""XR_NV_extension_851"" name="XR_NV_EXTENSION_851_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_852" number="852" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_852_SPEC_VERSION"/> + <enum value=""XR_NV_extension_852"" name="XR_NV_EXTENSION_852_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_853" number="853" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_853_SPEC_VERSION"/> + <enum value=""XR_NV_extension_853"" name="XR_NV_EXTENSION_853_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_854" number="854" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_854_SPEC_VERSION"/> + <enum value=""XR_NV_extension_854"" name="XR_NV_EXTENSION_854_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_855" number="855" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_855_SPEC_VERSION"/> + <enum value=""XR_NV_extension_855"" name="XR_NV_EXTENSION_855_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_856" number="856" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_856_SPEC_VERSION"/> + <enum value=""XR_NV_extension_856"" name="XR_NV_EXTENSION_856_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_857" number="857" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_857_SPEC_VERSION"/> + <enum value=""XR_NV_extension_857"" name="XR_NV_EXTENSION_857_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_858" number="858" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_858_SPEC_VERSION"/> + <enum value=""XR_NV_extension_858"" name="XR_NV_EXTENSION_858_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_NV_extension_859" number="859" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_NV_extension_859_SPEC_VERSION"/> + <enum value=""XR_NV_extension_859"" name="XR_NV_EXTENSION_859_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_860" number="860" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_860_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_860"" name="XR_QCOM_EXTENSION_860_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_861" number="861" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_861_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_861"" name="XR_QCOM_EXTENSION_861_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_862" number="862" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_862_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_862"" name="XR_QCOM_EXTENSION_862_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_863" number="863" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_863_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_863"" name="XR_QCOM_EXTENSION_863_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_864" number="864" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_864_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_864"" name="XR_QCOM_EXTENSION_864_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_865" number="865" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_865_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_865"" name="XR_QCOM_EXTENSION_865_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_866" number="866" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_866_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_866"" name="XR_QCOM_EXTENSION_866_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_867" number="867" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_867_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_867"" name="XR_QCOM_EXTENSION_867_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_868" number="868" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_868_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_868"" name="XR_QCOM_EXTENSION_868_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_QCOM_extension_869" number="869" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_QCOM_extension_869_SPEC_VERSION"/> + <enum value=""XR_QCOM_extension_869"" name="XR_QCOM_EXTENSION_869_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_870" number="870" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_870_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_870"" name="XR_EXT_EXTENSION_870_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_871" number="871" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_871_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_871"" name="XR_EXT_EXTENSION_871_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_KHR_extension_872" number="872" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_KHR_extension_872_SPEC_VERSION"/> + <enum value=""XR_KHR_extension_872"" name="XR_KHR_EXTENSION_872_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_KHR_extension_873" number="873" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_KHR_extension_873_SPEC_VERSION"/> + <enum value=""XR_KHR_extension_873"" name="XR_KHR_EXTENSION_873_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_874" number="874" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_874_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_874"" name="XR_EXT_EXTENSION_874_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_KHR_extended_result_name_lengths" number="875" type="instance" supported="openxr" ratified="openxr"> + <require> + <enum value="1" name="XR_KHR_extended_result_name_lengths_SPEC_VERSION"/> + <enum value=""XR_KHR_extended_result_name_lengths"" name="XR_KHR_EXTENDED_RESULT_NAME_LENGTHS_EXTENSION_NAME"/> + <command name="xrResultToString2KHR"/> + <enum value="256" name="XR_MAX_RESULT_STRING_SIZE_EXTENDED_KHR"/> + </require> + </extension> + + <extension name="XR_EXT_extension_876" number="876" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_876_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_876"" name="XR_EXT_EXTENSION_876_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_877" number="877" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_877_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_877"" name="XR_EXT_EXTENSION_877_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_878" number="878" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_878_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_878"" name="XR_EXT_EXTENSION_878_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_879" number="879" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_879_SPEC_VERSION"/> + <enum value=""XR_META_extension_879"" name="XR_META_EXTENSION_879_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_880" number="880" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_880_SPEC_VERSION"/> + <enum value=""XR_META_extension_880"" name="XR_META_EXTENSION_880_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_881" number="881" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_881_SPEC_VERSION"/> + <enum value=""XR_META_extension_881"" name="XR_META_EXTENSION_881_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_882" number="882" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_882_SPEC_VERSION"/> + <enum value=""XR_META_extension_882"" name="XR_META_EXTENSION_882_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_883" number="883" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_883_SPEC_VERSION"/> + <enum value=""XR_META_extension_883"" name="XR_META_EXTENSION_883_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_884" number="884" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_884_SPEC_VERSION"/> + <enum value=""XR_META_extension_884"" name="XR_META_EXTENSION_884_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_885" number="885" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_885_SPEC_VERSION"/> + <enum value=""XR_META_extension_885"" name="XR_META_EXTENSION_885_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_886" number="886" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_886_SPEC_VERSION"/> + <enum value=""XR_META_extension_886"" name="XR_META_EXTENSION_886_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_887" number="887" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_887_SPEC_VERSION"/> + <enum value=""XR_META_extension_887"" name="XR_META_EXTENSION_887_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_888" number="888" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_888_SPEC_VERSION"/> + <enum value=""XR_META_extension_888"" name="XR_META_EXTENSION_888_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_889" number="889" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_889_SPEC_VERSION"/> + <enum value=""XR_META_extension_889"" name="XR_META_EXTENSION_889_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_890" number="890" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_890_SPEC_VERSION"/> + <enum value=""XR_META_extension_890"" name="XR_META_EXTENSION_890_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_891" number="891" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_891_SPEC_VERSION"/> + <enum value=""XR_META_extension_891"" name="XR_META_EXTENSION_891_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_892" number="892" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_892_SPEC_VERSION"/> + <enum value=""XR_META_extension_892"" name="XR_META_EXTENSION_892_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_893" number="893" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_893_SPEC_VERSION"/> + <enum value=""XR_META_extension_893"" name="XR_META_EXTENSION_893_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_894" number="894" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_894_SPEC_VERSION"/> + <enum value=""XR_META_extension_894"" name="XR_META_EXTENSION_894_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_895" number="895" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_895_SPEC_VERSION"/> + <enum value=""XR_META_extension_895"" name="XR_META_EXTENSION_895_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_896" number="896" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_896_SPEC_VERSION"/> + <enum value=""XR_META_extension_896"" name="XR_META_EXTENSION_896_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_897" number="897" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_897_SPEC_VERSION"/> + <enum value=""XR_META_extension_897"" name="XR_META_EXTENSION_897_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_898" number="898" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_898_SPEC_VERSION"/> + <enum value=""XR_META_extension_898"" name="XR_META_EXTENSION_898_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_899" number="899" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_899_SPEC_VERSION"/> + <enum value=""XR_META_extension_899"" name="XR_META_EXTENSION_899_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_900" number="900" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_900_SPEC_VERSION"/> + <enum value=""XR_META_extension_900"" name="XR_META_EXTENSION_900_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_901" number="901" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_901_SPEC_VERSION"/> + <enum value=""XR_META_extension_901"" name="XR_META_EXTENSION_901_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_902" number="902" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_902_SPEC_VERSION"/> + <enum value=""XR_META_extension_902"" name="XR_META_EXTENSION_902_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_903" number="903" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_903_SPEC_VERSION"/> + <enum value=""XR_META_extension_903"" name="XR_META_EXTENSION_903_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_904" number="904" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_904_SPEC_VERSION"/> + <enum value=""XR_META_extension_904"" name="XR_META_EXTENSION_904_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_905" number="905" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_905_SPEC_VERSION"/> + <enum value=""XR_META_extension_905"" name="XR_META_EXTENSION_905_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_906" number="906" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_906_SPEC_VERSION"/> + <enum value=""XR_META_extension_906"" name="XR_META_EXTENSION_906_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_907" number="907" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_907_SPEC_VERSION"/> + <enum value=""XR_META_extension_907"" name="XR_META_EXTENSION_907_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_908" number="908" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_908_SPEC_VERSION"/> + <enum value=""XR_META_extension_908"" name="XR_META_EXTENSION_908_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_909" number="909" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_909_SPEC_VERSION"/> + <enum value=""XR_META_extension_909"" name="XR_META_EXTENSION_909_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_910" number="910" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_910_SPEC_VERSION"/> + <enum value=""XR_META_extension_910"" name="XR_META_EXTENSION_910_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_911" number="911" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_911_SPEC_VERSION"/> + <enum value=""XR_META_extension_911"" name="XR_META_EXTENSION_911_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_912" number="912" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_912_SPEC_VERSION"/> + <enum value=""XR_META_extension_912"" name="XR_META_EXTENSION_912_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_913" number="913" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_913_SPEC_VERSION"/> + <enum value=""XR_META_extension_913"" name="XR_META_EXTENSION_913_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_914" number="914" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_914_SPEC_VERSION"/> + <enum value=""XR_META_extension_914"" name="XR_META_EXTENSION_914_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_915" number="915" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_915_SPEC_VERSION"/> + <enum value=""XR_META_extension_915"" name="XR_META_EXTENSION_915_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_916" number="916" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_916_SPEC_VERSION"/> + <enum value=""XR_META_extension_916"" name="XR_META_EXTENSION_916_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_917" number="917" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_917_SPEC_VERSION"/> + <enum value=""XR_META_extension_917"" name="XR_META_EXTENSION_917_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_918" number="918" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_918_SPEC_VERSION"/> + <enum value=""XR_META_extension_918"" name="XR_META_EXTENSION_918_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_919" number="919" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_919_SPEC_VERSION"/> + <enum value=""XR_META_extension_919"" name="XR_META_EXTENSION_919_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_920" number="920" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_920_SPEC_VERSION"/> + <enum value=""XR_META_extension_920"" name="XR_META_EXTENSION_920_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_921" number="921" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_921_SPEC_VERSION"/> + <enum value=""XR_META_extension_921"" name="XR_META_EXTENSION_921_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_922" number="922" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_922_SPEC_VERSION"/> + <enum value=""XR_META_extension_922"" name="XR_META_EXTENSION_922_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_923" number="923" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_923_SPEC_VERSION"/> + <enum value=""XR_META_extension_923"" name="XR_META_EXTENSION_923_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_924" number="924" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_924_SPEC_VERSION"/> + <enum value=""XR_META_extension_924"" name="XR_META_EXTENSION_924_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_925" number="925" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_925_SPEC_VERSION"/> + <enum value=""XR_META_extension_925"" name="XR_META_EXTENSION_925_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_926" number="926" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_926_SPEC_VERSION"/> + <enum value=""XR_META_extension_926"" name="XR_META_EXTENSION_926_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_927" number="927" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_927_SPEC_VERSION"/> + <enum value=""XR_META_extension_927"" name="XR_META_EXTENSION_927_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_928" number="928" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_928_SPEC_VERSION"/> + <enum value=""XR_META_extension_928"" name="XR_META_EXTENSION_928_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_929" number="929" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_929_SPEC_VERSION"/> + <enum value=""XR_META_extension_929"" name="XR_META_EXTENSION_929_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_930" number="930" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_930_SPEC_VERSION"/> + <enum value=""XR_META_extension_930"" name="XR_META_EXTENSION_930_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_931" number="931" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_931_SPEC_VERSION"/> + <enum value=""XR_META_extension_931"" name="XR_META_EXTENSION_931_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_932" number="932" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_932_SPEC_VERSION"/> + <enum value=""XR_META_extension_932"" name="XR_META_EXTENSION_932_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_933" number="933" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_933_SPEC_VERSION"/> + <enum value=""XR_META_extension_933"" name="XR_META_EXTENSION_933_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_934" number="934" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_934_SPEC_VERSION"/> + <enum value=""XR_META_extension_934"" name="XR_META_EXTENSION_934_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_935" number="935" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_935_SPEC_VERSION"/> + <enum value=""XR_META_extension_935"" name="XR_META_EXTENSION_935_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_936" number="936" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_936_SPEC_VERSION"/> + <enum value=""XR_META_extension_936"" name="XR_META_EXTENSION_936_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_937" number="937" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_937_SPEC_VERSION"/> + <enum value=""XR_META_extension_937"" name="XR_META_EXTENSION_937_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_938" number="938" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_938_SPEC_VERSION"/> + <enum value=""XR_META_extension_938"" name="XR_META_EXTENSION_938_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_939" number="939" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_939_SPEC_VERSION"/> + <enum value=""XR_META_extension_939"" name="XR_META_EXTENSION_939_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_940" number="940" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_940_SPEC_VERSION"/> + <enum value=""XR_META_extension_940"" name="XR_META_EXTENSION_940_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_941" number="941" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_941_SPEC_VERSION"/> + <enum value=""XR_META_extension_941"" name="XR_META_EXTENSION_941_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_942" number="942" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_942_SPEC_VERSION"/> + <enum value=""XR_META_extension_942"" name="XR_META_EXTENSION_942_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_943" number="943" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_943_SPEC_VERSION"/> + <enum value=""XR_META_extension_943"" name="XR_META_EXTENSION_943_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_944" number="944" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_944_SPEC_VERSION"/> + <enum value=""XR_META_extension_944"" name="XR_META_EXTENSION_944_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_945" number="945" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_945_SPEC_VERSION"/> + <enum value=""XR_META_extension_945"" name="XR_META_EXTENSION_945_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_946" number="946" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_946_SPEC_VERSION"/> + <enum value=""XR_META_extension_946"" name="XR_META_EXTENSION_946_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_947" number="947" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_947_SPEC_VERSION"/> + <enum value=""XR_META_extension_947"" name="XR_META_EXTENSION_947_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_948" number="948" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_948_SPEC_VERSION"/> + <enum value=""XR_META_extension_948"" name="XR_META_EXTENSION_948_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_949" number="949" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_949_SPEC_VERSION"/> + <enum value=""XR_META_extension_949"" name="XR_META_EXTENSION_949_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_950" number="950" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_950_SPEC_VERSION"/> + <enum value=""XR_META_extension_950"" name="XR_META_EXTENSION_950_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_951" number="951" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_951_SPEC_VERSION"/> + <enum value=""XR_META_extension_951"" name="XR_META_EXTENSION_951_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_952" number="952" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_952_SPEC_VERSION"/> + <enum value=""XR_META_extension_952"" name="XR_META_EXTENSION_952_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_953" number="953" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_953_SPEC_VERSION"/> + <enum value=""XR_META_extension_953"" name="XR_META_EXTENSION_953_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_954" number="954" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_954_SPEC_VERSION"/> + <enum value=""XR_META_extension_954"" name="XR_META_EXTENSION_954_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_955" number="955" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_955_SPEC_VERSION"/> + <enum value=""XR_META_extension_955"" name="XR_META_EXTENSION_955_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_956" number="956" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_956_SPEC_VERSION"/> + <enum value=""XR_META_extension_956"" name="XR_META_EXTENSION_956_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_957" number="957" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_957_SPEC_VERSION"/> + <enum value=""XR_META_extension_957"" name="XR_META_EXTENSION_957_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_958" number="958" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_958_SPEC_VERSION"/> + <enum value=""XR_META_extension_958"" name="XR_META_EXTENSION_958_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_959" number="959" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_959_SPEC_VERSION"/> + <enum value=""XR_META_extension_959"" name="XR_META_EXTENSION_959_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_960" number="960" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_960_SPEC_VERSION"/> + <enum value=""XR_META_extension_960"" name="XR_META_EXTENSION_960_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_961" number="961" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_961_SPEC_VERSION"/> + <enum value=""XR_META_extension_961"" name="XR_META_EXTENSION_961_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_962" number="962" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_962_SPEC_VERSION"/> + <enum value=""XR_META_extension_962"" name="XR_META_EXTENSION_962_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_963" number="963" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_963_SPEC_VERSION"/> + <enum value=""XR_META_extension_963"" name="XR_META_EXTENSION_963_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_964" number="964" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_964_SPEC_VERSION"/> + <enum value=""XR_META_extension_964"" name="XR_META_EXTENSION_964_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_965" number="965" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_965_SPEC_VERSION"/> + <enum value=""XR_META_extension_965"" name="XR_META_EXTENSION_965_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_966" number="966" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_966_SPEC_VERSION"/> + <enum value=""XR_META_extension_966"" name="XR_META_EXTENSION_966_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_967" number="967" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_967_SPEC_VERSION"/> + <enum value=""XR_META_extension_967"" name="XR_META_EXTENSION_967_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_968" number="968" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_968_SPEC_VERSION"/> + <enum value=""XR_META_extension_968"" name="XR_META_EXTENSION_968_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_969" number="969" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_969_SPEC_VERSION"/> + <enum value=""XR_META_extension_969"" name="XR_META_EXTENSION_969_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_970" number="970" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_970_SPEC_VERSION"/> + <enum value=""XR_META_extension_970"" name="XR_META_EXTENSION_970_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_971" number="971" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_971_SPEC_VERSION"/> + <enum value=""XR_META_extension_971"" name="XR_META_EXTENSION_971_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_972" number="972" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_972_SPEC_VERSION"/> + <enum value=""XR_META_extension_972"" name="XR_META_EXTENSION_972_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_973" number="973" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_973_SPEC_VERSION"/> + <enum value=""XR_META_extension_973"" name="XR_META_EXTENSION_973_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_974" number="974" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_974_SPEC_VERSION"/> + <enum value=""XR_META_extension_974"" name="XR_META_EXTENSION_974_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_975" number="975" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_975_SPEC_VERSION"/> + <enum value=""XR_META_extension_975"" name="XR_META_EXTENSION_975_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_976" number="976" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_976_SPEC_VERSION"/> + <enum value=""XR_META_extension_976"" name="XR_META_EXTENSION_976_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_977" number="977" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_977_SPEC_VERSION"/> + <enum value=""XR_META_extension_977"" name="XR_META_EXTENSION_977_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_META_extension_978" number="978" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_META_extension_978_SPEC_VERSION"/> + <enum value=""XR_META_extension_978"" name="XR_META_EXTENSION_978_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_EXT_extension_979" number="979" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_EXT_extension_979_SPEC_VERSION"/> + <enum value=""XR_EXT_extension_979"" name="XR_EXT_EXTENSION_979_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_980" number="980" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_980_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_980"" name="XR_ANDROID_EXTENSION_980_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_981" number="981" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_981_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_981"" name="XR_ANDROID_EXTENSION_981_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_982" number="982" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_982_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_982"" name="XR_ANDROID_EXTENSION_982_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_983" number="983" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_983_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_983"" name="XR_ANDROID_EXTENSION_983_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_984" number="984" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_984_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_984"" name="XR_ANDROID_EXTENSION_984_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_985" number="985" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_985_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_985"" name="XR_ANDROID_EXTENSION_985_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_986" number="986" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_986_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_986"" name="XR_ANDROID_EXTENSION_986_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_987" number="987" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_987_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_987"" name="XR_ANDROID_EXTENSION_987_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_988" number="988" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_988_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_988"" name="XR_ANDROID_EXTENSION_988_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_989" number="989" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_989_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_989"" name="XR_ANDROID_EXTENSION_989_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_990" number="990" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_990_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_990"" name="XR_ANDROID_EXTENSION_990_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_991" number="991" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_991_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_991"" name="XR_ANDROID_EXTENSION_991_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_992" number="992" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_992_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_992"" name="XR_ANDROID_EXTENSION_992_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_993" number="993" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_993_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_993"" name="XR_ANDROID_EXTENSION_993_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_994" number="994" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_994_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_994"" name="XR_ANDROID_EXTENSION_994_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_995" number="995" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_995_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_995"" name="XR_ANDROID_EXTENSION_995_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_996" number="996" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_996_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_996"" name="XR_ANDROID_EXTENSION_996_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_997" number="997" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_997_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_997"" name="XR_ANDROID_EXTENSION_997_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_998" number="998" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_998_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_998"" name="XR_ANDROID_EXTENSION_998_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_999" number="999" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_999_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_999"" name="XR_ANDROID_EXTENSION_999_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_1000" number="1000" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_1000_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_1000"" name="XR_ANDROID_EXTENSION_1000_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_1001" number="1001" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_1001_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_1001"" name="XR_ANDROID_EXTENSION_1001_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_1002" number="1002" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_1002_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_1002"" name="XR_ANDROID_EXTENSION_1002_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_1003" number="1003" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_1003_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_1003"" name="XR_ANDROID_EXTENSION_1003_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_1004" number="1004" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_1004_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_1004"" name="XR_ANDROID_EXTENSION_1004_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_1005" number="1005" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_1005_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_1005"" name="XR_ANDROID_EXTENSION_1005_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_1006" number="1006" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_1006_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_1006"" name="XR_ANDROID_EXTENSION_1006_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_1007" number="1007" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_1007_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_1007"" name="XR_ANDROID_EXTENSION_1007_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_1008" number="1008" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_1008_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_1008"" name="XR_ANDROID_EXTENSION_1008_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_1009" number="1009" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_1009_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_1009"" name="XR_ANDROID_EXTENSION_1009_EXTENSION_NAME"/> + </require> + </extension> + + <extension name="XR_ANDROID_extension_1010" number="1010" type="instance" supported="disabled"> + <require> + <enum value="1" name="XR_ANDROID_extension_1010_SPEC_VERSION"/> + <enum value=""XR_ANDROID_extension_1010"" name="XR_ANDROID_EXTENSION_1010_EXTENSION_NAME"/> + </require> + </extension> + + </extensions> + +</registry> diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/.clang-format b/shadps4-arm64-main/externals/openxr-sdk/src/.clang-format new file mode 100644 index 0000000..3214158 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/.clang-format @@ -0,0 +1,10 @@ +--- +# Copyright (c) 2017-2026 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 +# Use defaults from the Google style with the following exceptions: +BasedOnStyle: Google +IndentWidth: 4 +ColumnLimit: 132 +SortIncludes: false +... diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/CMakeLists.txt b/shadps4-arm64-main/externals/openxr-sdk/src/CMakeLists.txt new file mode 100644 index 0000000..b26bbcc --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/CMakeLists.txt @@ -0,0 +1,646 @@ +# Copyright (c) 2017-2026 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +if(POLICY CMP0075) + cmake_policy(SET CMP0075 NEW) +endif() + +# Entire project uses C++17 +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_POSITION_INDEPENDENT_CODE ON) +list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake") +list( + APPEND CMAKE_MODULE_PATH + "${CMAKE_CURRENT_SOURCE_DIR}/external/sanitizers-cmake/cmake" +) + +include(StdFilesystemFlags) + +find_package(Sanitizers QUIET) + +### Dependencies + +set(XR_USE_GRAPHICS_API_OPENGL FALSE) +set(XR_USE_GRAPHICS_API_OPENGL_ES FALSE) +set(XR_USE_GRAPHICS_API_VULKAN FALSE) +set(XR_USE_GRAPHICS_API_D3D11 FALSE) +set(XR_USE_GRAPHICS_API_D3D12 FALSE) +set(XR_USE_GRAPHICS_API_METAL FALSE) + +set(OPENGLES_INCOMPATIBLE TRUE) +set(EGL_INCOMPATIBLE FALSE) +set(OPENGL_INCOMPATIBLE FALSE) +set(VULKAN_INCOMPATIBLE FALSE) +set(METAL_INCOMPATIBLE TRUE) + +# CMake will detect OpenGL/Vulkan which are not compatible with UWP and ARM/ARM64 on Windows so skip it in these cases. +if(CMAKE_SYSTEM_NAME STREQUAL "WindowsStore") + set(OPENGL_INCOMPATIBLE TRUE) + set(VULKAN_INCOMPATIBLE TRUE) + message(STATUS "OpenGL/Vulkan disabled due to incompatibility with UWP.") +elseif(WIN32) + if(CMAKE_SYSTEM_NAME STREQUAL "ARM" OR CMAKE_C_COMPILER_ARCHITECTURE_ID + STREQUAL "ARMV7" + ) + set(OPENGL_INCOMPATIBLE TRUE) + set(VULKAN_INCOMPATIBLE TRUE) + message( + STATUS + "OpenGL/Vulkan disabled due to incompatibility with Windows on ARM 32-bit" + ) + endif() +elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin") + set(OPENGL_INCOMPATIBLE TRUE) + set(EGL_INCOMPATIBLE TRUE) + message(STATUS "OpenGL and EGL disabled as no bindings exist for OpenGL on Darwin") + set(METAL_INCOMPATIBLE FALSE) +elseif(ANDROID) + set(OPENGL_INCOMPATIBLE TRUE) + find_path( + ANDROID_NATIVE_APP_GLUE android_native_app_glue.h + PATHS "${ANDROID_NDK}/sources/android/native_app_glue" + ) + if(ANDROID_NATIVE_APP_GLUE) + # Needed by gfxwrapper + set(OPENGLES_INCOMPATIBLE FALSE) + endif() + if(ANDROID_PLATFORM_LEVEL LESS 24) + set(VULKAN_INCOMPATIBLE TRUE) + message( + STATUS + "Vulkan disabled due to incompatibility: need to target at least API 24" + ) + endif() +endif() + +if(WIN32) + set(EGL_INCOMPATIBLE TRUE) + message(STATUS "EGL disabled") +endif() + +if(NOT OPENGL_INCOMPATIBLE) + set(OpenGL_GL_PREFERENCE GLVND) + find_package(OpenGL) + + if(OPENGL_FOUND) + set(XR_USE_GRAPHICS_API_OPENGL TRUE) + add_definitions(-DXR_USE_GRAPHICS_API_OPENGL) + message(STATUS "Enabling OpenGL support") + elseif(BUILD_ALL_EXTENSIONS) + message(FATAL_ERROR "OpenGL not found") + endif() +endif() + +if(NOT OPENGLES_INCOMPATIBLE) + find_package(OpenGLES COMPONENTS V3 V2) + find_package(EGL) + if(OPENGLES_FOUND AND EGL_FOUND) + set(XR_USE_GRAPHICS_API_OPENGL_ES TRUE) + add_definitions(-DXR_USE_GRAPHICS_API_OPENGL_ES) + message(STATUS "Enabling OpenGL|ES support") + elseif(BUILD_ALL_EXTENSIONS) + message(FATAL_ERROR "OpenGL|ES not found") + endif() +endif() + + +if(NOT EGL_INCOMPATIBLE) + find_package(EGL) + if(EGL_FOUND) + set(XR_USE_PLATFORM_EGL TRUE) + add_definitions(-DXR_USE_PLATFORM_EGL) + message(STATUS "Enabling EGL support") + elseif(BUILD_ALL_EXTENSIONS) + message(FATAL_ERROR "EGL not found") + endif() +endif() + +if(NOT VULKAN_INCOMPATIBLE) + # Find the Vulkan headers + find_package(Vulkan) + if(Vulkan_FOUND) + set(XR_USE_GRAPHICS_API_VULKAN TRUE) + add_definitions(-DXR_USE_GRAPHICS_API_VULKAN) + message(STATUS "Enabling Vulkan support") + elseif(BUILD_ALL_EXTENSIONS) + message(FATAL_ERROR "Vulkan headers not found") + endif() +endif() + +if(NOT METAL_INCOMPATIBLE) + find_package(MetalTools) + if(MetalTools_FOUND) + set(XR_USE_GRAPHICS_API_METAL TRUE) + add_definitions(-DXR_USE_GRAPHICS_API_METAL) + message(STATUS "Enabling Metal support") + elseif(BUILD_ALL_EXTENSIONS) + message(FATAL_ERROR "Metal not found - full Xcode install required") + else() + message(STATUS "Metal not found - full Xcode install required") + endif() +endif() + +find_package(Threads REQUIRED) +find_package(JsonCpp) + +### All options defined here +option(BUILD_LOADER "Build loader" ON) +option(BUILD_ALL_EXTENSIONS "Build loader and layers with all extensions" OFF) +option( + BUILD_LOADER_WITH_EXCEPTION_HANDLING + "Enable exception handling in the loader. Leave this on unless your standard library is built to not throw." + ON +) + +if(WIN32) + set(OPENXR_DEBUG_POSTFIX + d + CACHE STRING "OpenXR loader debug postfix." + ) +else() + set(OPENXR_DEBUG_POSTFIX + "" + CACHE STRING "OpenXR loader debug postfix." + ) +endif() + +if(CMAKE_SYSTEM_NAME STREQUAL "Windows") + option(DYNAMIC_LOADER "Build the loader as a .dll library" OFF) +else() + option(DYNAMIC_LOADER "Build the loader as a .dll library" ON) +endif() +if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/api_layers/CMakeLists.txt") + option(BUILD_API_LAYERS "Build API layers" ON) +endif() +if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/tests/CMakeLists.txt") + option(BUILD_TESTS "Build tests" ON) +endif() +if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/conformance/CMakeLists.txt") + option(BUILD_CONFORMANCE_TESTS "Build conformance tests" ON) +endif() +if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/tests/hello_xr/CMakeLists.txt") + option(BUILD_SDK_TESTS "Build SDK samples" ON) +endif() +include(CMakeDependentOption) + +cmake_dependent_option( + BUILD_WITH_SYSTEM_JSONCPP + "Use system jsoncpp instead of vendored source" + ON + "JSONCPP_FOUND" + OFF +) +cmake_dependent_option( + BUILD_WITH_STD_FILESYSTEM + "Use std::[experimental::]filesystem." + ON + "HAVE_FILESYSTEM_WITHOUT_LIB OR HAVE_FILESYSTEM_NEEDING_LIBSTDCXXFS OR HAVE_FILESYSTEM_NEEDING_LIBCXXFS" + OFF +) + +# Several files use these compile time OS switches +if(WIN32) + add_definitions(-DXR_OS_WINDOWS) + add_definitions(-DNOMINMAX) +elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux") + add_definitions(-DXR_OS_LINUX) +elseif(ANDROID) + add_definitions(-DXR_OS_ANDROID) +elseif(APPLE) + add_definitions(-DXR_OS_APPLE) +endif() + +# /EHsc (support for C++ exceptions) is default in most configurations but seems missing when building arm/arm64. +if(MSVC) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc") +endif() + +# OpenGL function loader: generated by GLAD2. +# Not present in -SDK because not needed for the loader +if((OPENGL_FOUND OR OpenGLES_FOUND) + AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/external/glad2" +) + add_subdirectory(external/glad2) +endif() + +# This is a little helper library for setting up OpenGL +# Not present in -SDK because not needed for the loader +if((OPENGL_FOUND OR OpenGLES_FOUND) + AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/common/gfxwrapper_opengl.c" +) + add_library( + openxr-gfxwrapper STATIC common/gfxwrapper_opengl.c + common/gfxwrapper_opengl.h + ) + add_sanitizers(openxr-gfxwrapper) + target_link_libraries(openxr-gfxwrapper PUBLIC openxr-glad-loader) + + if(ANDROID) + target_include_directories( + openxr-gfxwrapper PUBLIC "${ANDROID_NATIVE_APP_GLUE}" + ) + + # Note: For some reason, just adding this to the gfxwrapper library results in failure at load time. + # So, each consuming target must add $<TARGET_OBJECTS:android_native_app_glue> to their sources + add_library( + android_native_app_glue OBJECT + "${ANDROID_NATIVE_APP_GLUE}/android_native_app_glue.c" + ) + target_include_directories( + android_native_app_glue PUBLIC "${ANDROID_NATIVE_APP_GLUE}" + ) + target_compile_options( + android_native_app_glue PRIVATE -Wno-unused-parameter + ) + elseif(APPLE) + target_compile_options(openxr-gfxwrapper PRIVATE -x objective-c++) + target_link_libraries( + openxr-gfxwrapper + PUBLIC "-framework AppKit" "-framework Foundation" + "-framework CoreGraphics" + ) + endif() + set_target_properties(openxr-gfxwrapper PROPERTIES FOLDER ${HELPER_FOLDER}) + message( + STATUS + "Enabling OpenGL support in hello_xr, loader_test, and conformance, if configured" + ) +endif() + +# Determine the presentation backend for Linux systems. +# Use an include because the code is pretty big. +if(CMAKE_SYSTEM_NAME STREQUAL "Linux") + include(presentation) +endif() + +# Several files use these compile time platform switches +if(WIN32) + add_definitions(-DXR_USE_PLATFORM_WIN32) +elseif(APPLE) + if(CMAKE_SYSTEM_NAME STREQUAL "Darwin") + if(DARWIN_TARGET_OS_NAME STREQUAL "ios") + add_definitions(-DXR_USE_PLATFORM_IOS) + else() + add_definitions(-DXR_USE_PLATFORM_MACOS) + endif() + endif() +elseif(ANDROID) + add_definitions(-DXR_USE_PLATFORM_ANDROID) + set(OPENXR_ANDROID_VERSION_SUFFIX + "" + CACHE STRING "Suffix for generated Android artifacts." + ) +elseif(PRESENTATION_BACKEND MATCHES "xlib") + add_definitions(-DXR_USE_PLATFORM_XLIB) +elseif(PRESENTATION_BACKEND MATCHES "xcb") + add_definitions(-DXR_USE_PLATFORM_XCB) + + # TODO remove once conformance supports XCB + set(BUILD_CONFORMANCE_TESTS OFF) +elseif(PRESENTATION_BACKEND MATCHES "wayland") + add_definitions(-DXR_USE_PLATFORM_WAYLAND) + + # TODO remove once conformance supports Wayland + set(BUILD_CONFORMANCE_TESTS OFF) +endif() + +if(BUILD_CONFORMANCE_TESTS AND NOT ANDROID) + set(BUILD_CONFORMANCE_CLI ON) +else() + set(BUILD_CONFORMANCE_CLI OFF) +endif() + +set(OPENXR_ALL_SUPPORTED_DEFINES) +if(BUILD_WITH_XLIB_HEADERS) + list(APPEND OPENXR_ALL_SUPPORTED_DEFINES XR_USE_PLATFORM_XLIB) +endif() + +if(BUILD_WITH_XCB_HEADERS) + list(APPEND OPENXR_ALL_SUPPORTED_DEFINES XR_USE_PLATFORM_XCB) +endif() + +if(BUILD_WITH_WAYLAND_HEADERS) + list(APPEND OPENXR_ALL_SUPPORTED_DEFINES XR_USE_PLATFORM_WAYLAND) +endif() + +# Find glslc shader compiler. +# On Android, the NDK includes the binary, so no external dependency. +if(ANDROID) + file( + GLOB + glslc_folders + CONFIGURE_DEPENDS + ${ANDROID_NDK}/shader-tools/* + ) + find_program( + GLSL_COMPILER glslc + PATHS ${glslc_folders} + NO_DEFAULT_PATH + ) +else() + if($ENV{VULKAN_SDK}) + file(TO_CMAKE_PATH "$ENV{VULKAN_SDK}" VULKAN_SDK) + file( + GLOB + glslc_folders + CONFIGURE_DEPENDS + ${VULKAN_SDK}/* + ) + endif() + find_program( + GLSL_COMPILER glslc + PATHS ${glslc_folders} + HINTS "${Vulkan_GLSLC_EXECUTABLE}" + ) +endif() +find_program( + GLSLANG_VALIDATOR glslangValidator + HINTS "${Vulkan_GLSLANG_VALIDATOR_EXECUTABLE}" +) +if(GLSL_COMPILER) + message(STATUS "Found glslc: ${GLSL_COMPILER}") +elseif(GLSLANG_VALIDATOR) + message(STATUS "Found glslangValidator: ${GLSLANG_VALIDATOR}") +else() + message(STATUS "Could NOT find glslc, using precompiled .spv files") +endif() + +function(compile_glsl run_target_name) + set(glsl_output_files "") + foreach(in_file IN LISTS ARGN) + get_filename_component(glsl_stage "${in_file}" NAME_WE) + set(out_file "${CMAKE_CURRENT_BINARY_DIR}/${glsl_stage}.spv") + if(GLSL_COMPILER) + # Run glslc if we can find it + add_custom_command( + OUTPUT "${out_file}" + COMMAND + "${GLSL_COMPILER}" -mfmt=c -fshader-stage=${glsl_stage} + "${in_file}" -o "${out_file}" + DEPENDS "${in_file}" + WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + VERBATIM + ) + elseif(GLSLANG_VALIDATOR) + # Run glslangValidator if we can find it + add_custom_command( + OUTPUT "${out_file}" + COMMAND + "${GLSLANG_VALIDATOR}" -V -S ${glsl_stage} "${in_file}" -x + -o "${out_file}" + DEPENDS "${in_file}" + WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + VERBATIM + ) + else() + # Use the precompiled .spv files + get_filename_component(glsl_src_dir "${in_file}" DIRECTORY) + set(precompiled_file "${glsl_src_dir}/${glsl_stage}.spv") + configure_file("${precompiled_file}" "${out_file}" COPYONLY) + endif() + list(APPEND glsl_output_files "${out_file}") + endforeach() + add_custom_target(${run_target_name} ALL DEPENDS ${glsl_output_files}) + set_target_properties(${run_target_name} PROPERTIES FOLDER ${HELPER_FOLDER}) + +endfunction() + +# Not available in MinGW +if(MSVC) + set(XR_USE_GRAPHICS_API_D3D11 TRUE) + add_definitions(-DXR_USE_GRAPHICS_API_D3D11) + set(XR_USE_GRAPHICS_API_D3D12 TRUE) + add_definitions(-DXR_USE_GRAPHICS_API_D3D12) +endif() + +# Check for the existence of the secure_getenv or __secure_getenv commands +include(CheckFunctionExists) + +check_function_exists(secure_getenv HAVE_SECURE_GETENV) +check_function_exists(__secure_getenv HAVE___SECURE_GETENV) +configure_file(common_config.h.in "${CMAKE_CURRENT_BINARY_DIR}/common_config.h") +add_definitions(-DOPENXR_HAVE_COMMON_CONFIG) + +include(CheckSymbolExists) +if(WIN32) + check_symbol_exists(timespec_get time.h HAVE_TIMESPEC) +else() + check_symbol_exists(clock_gettime time.h HAVE_TIMESPEC) +endif() +if(HAVE_TIMESPEC) + add_definitions(-DXR_USE_TIMESPEC) +endif() + +# Set up the OpenXR version variables, used by several targets in this project. +include(${CMAKE_CURRENT_SOURCE_DIR}/version.cmake) + +# General code generation macro used by several targets. +macro(run_xr_xml_generate dependency output) + if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${output}" + AND NOT BUILD_FORCE_GENERATION + ) + # pre-generated found + message( + STATUS "Found and will use pre-generated ${output} in source tree" + ) + list(APPEND GENERATED_OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/${output}") + else() + if(NOT Python3_EXECUTABLE) + message( + FATAL_ERROR + "Python 3 not found, but pre-generated ${CMAKE_CURRENT_SOURCE_DIR}/${output} not found" + ) + endif() + add_custom_command( + OUTPUT "${output}" + COMMAND + "${CMAKE_COMMAND}" -E env "PYTHONPATH=${CODEGEN_PYTHON_PATH}" + "${Python3_EXECUTABLE}" + "${PROJECT_SOURCE_DIR}/src/scripts/src_genxr.py" -registry + "${PROJECT_SOURCE_DIR}/specification/registry/xr.xml" + "${output}" + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} + DEPENDS + "${PROJECT_SOURCE_DIR}/specification/registry/xr.xml" + "${PROJECT_SOURCE_DIR}/specification/scripts/generator.py" + "${PROJECT_SOURCE_DIR}/specification/scripts/reg.py" + "${PROJECT_SOURCE_DIR}/src/scripts/${dependency}" + "${PROJECT_SOURCE_DIR}/src/scripts/src_genxr.py" + ${ARGN} + VERBATIM + COMMENT + "Generating ${output} using ${Python3_EXECUTABLE} on ${dependency}" + ) + # cmake-format: off + set_source_files_properties(${output} + PROPERTIES + GENERATED TRUE + SKIP_LINTING ON + ) + # cmake-format: on + list(APPEND GENERATED_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${output}") + list(APPEND GENERATED_DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/${output}") + endif() +endmacro() + +# Layer JSON generation macro used by several targets. +macro( + gen_xr_layer_json + filename + layername + libfile + version + desc + genbad +) + add_custom_command( + OUTPUT "${filename}" + COMMAND + "${CMAKE_COMMAND}" -E env "PYTHONPATH=${CODEGEN_PYTHON_PATH}" + "${Python3_EXECUTABLE}" + "${PROJECT_SOURCE_DIR}/src/scripts/generate_api_layer_manifest.py" + -f "${filename}" -n ${layername} -l ${libfile} -a ${MAJOR}.${MINOR} + -v ${version} ${genbad} -d ${desc} + WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" + DEPENDS + "${PROJECT_SOURCE_DIR}/src/scripts/generate_api_layer_manifest.py" + COMMENT + "Generating API Layer JSON ${filename} using -f ${filename} -n ${layername} -l ${libfile} -a ${MAJOR}.${MINOR} -v ${version} ${genbad} -d ${desc}" + VERBATIM + ) +endmacro() + +# Custom target for generated dispatch table sources, used by several targets. +unset(GENERATED_OUTPUT) +unset(GENERATED_DEPENDS) +run_xr_xml_generate(utility_source_generator.py xr_generated_dispatch_table.h) +run_xr_xml_generate(utility_source_generator.py xr_generated_dispatch_table.c) +set(COMMON_GENERATED_OUTPUT ${GENERATED_OUTPUT}) +set(COMMON_GENERATED_DEPENDS ${GENERATED_DEPENDS}) + +if(COMMON_GENERATED_DEPENDS) + add_custom_target( + xr_common_generated_files DEPENDS ${COMMON_GENERATED_DEPENDS} + ) +else() + add_custom_target(xr_common_generated_files) +endif() + +set_target_properties( + xr_common_generated_files PROPERTIES FOLDER ${CODEGEN_FOLDER} +) + +unset(GENERATED_OUTPUT) +unset(GENERATED_DEPENDS) +run_xr_xml_generate( + utility_source_generator.py xr_generated_dispatch_table_core.h +) +run_xr_xml_generate( + utility_source_generator.py xr_generated_dispatch_table_core.c +) +set(LOADER_GENERATED_OUTPUT ${GENERATED_OUTPUT}) +set(LOADER_GENERATED_DEPENDS ${GENERATED_DEPENDS}) + +unset(GENERATED_OUTPUT) +unset(GENERATED_DEPENDS) + +if(LOADER_GENERATED_DEPENDS) + add_custom_target( + xr_global_generated_files DEPENDS ${LOADER_GENERATED_DEPENDS} + ) +else() + add_custom_target(xr_global_generated_files) +endif() + +set_target_properties( + xr_global_generated_files PROPERTIES FOLDER ${CODEGEN_FOLDER} +) + +if(NOT MSVC) + include(CheckCXXCompilerFlag) + include(CheckCCompilerFlag) + foreach( + FLAG + -Wall + -Werror=unused-parameter + -Werror=unused-argument + -Wpointer-arith + ) + string( + REGEX + REPLACE + "[^A-Za-z0-9]" + "" + _flagvar + "${FLAG}" + ) + check_cxx_compiler_flag(${FLAG} SUPPORTS_${_flagvar}) + if(SUPPORTS_${_flagvar}) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${FLAG}") + endif() + check_c_compiler_flag(${FLAG} SUPPORTS_C_${_flagvar}) + if(SUPPORTS_C_${_flagvar}) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${FLAG}") + endif() + endforeach() + if(APPLE) + set(CMAKE_SHARED_LINKER_FLAGS + "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-undefined,error" + ) + elseif(NOT WIN32) + if(NOT SANITIZE_ADDRESS) + set(CMAKE_SHARED_LINKER_FLAGS + "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-undefined" + ) + endif() + endif() +endif() + +if(ANDROID) + find_library(ANDROID_LIBRARY NAMES android) + find_library(ANDROID_LOG_LIBRARY NAMES log) +endif() + +if(BUILD_LOADER) + add_subdirectory(loader) +endif() + +if(BUILD_API_LAYERS) + add_subdirectory(api_layers) +endif() + +if(BUILD_TESTS OR BUILD_CONFORMANCE_TESTS) + add_subdirectory(external/catch2) + add_sanitizers(Catch2) + add_sanitizers(Catch2WithMain) + + file(GLOB_RECURSE EXTERNAL_SOURCES external/catch2/*.cpp) + # cmake-format: off + set_source_files_properties(${EXTERNAL_SOURCES} + TARGET_DIRECTORY Catch2::Catch2 + PROPERTIES SKIP_LINTING ON + ) + # cmake-format: on +endif() + +if(BUILD_TESTS) + add_subdirectory(tests) +endif() + +if(BUILD_CONFORMANCE_TESTS) + add_subdirectory(conformance) +endif() diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/cmake/FindEGL.cmake b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/FindEGL.cmake new file mode 100644 index 0000000..7bc836f --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/FindEGL.cmake @@ -0,0 +1,179 @@ +#.rst: +# FindEGL +# ------- +# +# Try to find EGL. +# +# This will define the following variables: +# +# ``EGL_FOUND`` +# True if (the requested version of) EGL is available +# ``EGL_VERSION`` +# The version of EGL; note that this is the API version defined in the +# headers, rather than the version of the implementation (eg: Mesa) +# ``EGL_LIBRARIES`` +# This can be passed to target_link_libraries() instead of the ``EGL::EGL`` +# target +# ``EGL_INCLUDE_DIRS`` +# This should be passed to target_include_directories() if the target is not +# used for linking +# ``EGL_DEFINITIONS`` +# This should be passed to target_compile_options() if the target is not +# used for linking +# +# If ``EGL_FOUND`` is TRUE, it will also define the following imported target: +# +# ``EGL::EGL`` +# The EGL library +# +# In general we recommend using the imported target, as it is easier to use. +# Bear in mind, however, that if the target is in the link interface of an +# exported library, it must be made available by the package config file. +# +# Since pre-1.0.0. + +# SPDX-License-Identifier: BSD-3-Clause +# +# Note: This module is originally from the KDE "Extra CMake Modules" repo, +# adapted to work standalone. Original source: +# https://github.com/KDE/extra-cmake-modules/blob/3b0bf71a72789eb2b79310b4f67602115e347f56/find-modules/FindEGL.cmake +#============================================================================= +# Copyright 2014 Alex Merry <alex.merry@kde.org> +# Copyright 2014 Martin Gräßlin <mgraesslin@kde.org> +# Copyright 2019, 2021 Rylie Pavlik <rylie.pavlik@collabora.com> +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# 1. Redistributions of source code must retain the copyright +# notice, this list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# 3. The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +#============================================================================= + +include(CheckCXXSourceCompiles) +include(CMakePushCheckState) + +# Use pkg-config to get the directories and then use these values +# in the FIND_PATH() and FIND_LIBRARY() calls +if(NOT ANDROID) + find_package(PkgConfig QUIET) + if(PKGCONFIG_FOUND) + pkg_check_modules(PKG_EGL QUIET egl) + endif() +endif() + +set(EGL_DEFINITIONS ${PKG_EGL_CFLAGS_OTHER}) + +find_path(EGL_INCLUDE_DIR + NAMES + EGL/egl.h + HINTS + ${PKG_EGL_INCLUDE_DIRS} +) +find_library(EGL_LIBRARY + NAMES + EGL + HINTS + ${PKG_EGL_LIBRARY_DIRS} +) + +# NB: We do *not* use the version information from pkg-config, as that +# is the implementation version (eg: the Mesa version) +if(EGL_INCLUDE_DIR) + # egl.h has defines of the form EGL_VERSION_x_y for each supported + # version; so the header for EGL 1.1 will define EGL_VERSION_1_0 and + # EGL_VERSION_1_1. Finding the highest supported version involves + # finding all these defines and selecting the highest numbered. + file(READ "${EGL_INCLUDE_DIR}/EGL/egl.h" _EGL_header_contents) + string(REGEX MATCHALL + "[ \t]EGL_VERSION_[0-9_]+" + _EGL_version_lines + "${_EGL_header_contents}" + ) + unset(_EGL_header_contents) + foreach(_EGL_version_line ${_EGL_version_lines}) + string(REGEX REPLACE + "[ \t]EGL_VERSION_([0-9_]+)" + "\\1" + _version_candidate + "${_EGL_version_line}" + ) + string(REPLACE "_" "." _version_candidate "${_version_candidate}") + if(NOT DEFINED EGL_VERSION OR EGL_VERSION VERSION_LESS _version_candidate) + set(EGL_VERSION "${_version_candidate}") + endif() + endforeach() + unset(_EGL_version_lines) +endif() + +cmake_push_check_state(RESET) +list(APPEND CMAKE_REQUIRED_LIBRARIES "${EGL_LIBRARY}") +list(APPEND CMAKE_REQUIRED_INCLUDES "${EGL_INCLUDE_DIR}") + +check_cxx_source_compiles(" +#include <EGL/egl.h> + +int main(int argc, char *argv[]) { + EGLint x = 0; EGLDisplay dpy = 0; EGLContext ctx = 0; + eglDestroyContext(dpy, ctx); +}" HAVE_EGL) + +cmake_pop_check_state() + +set(required_vars EGL_INCLUDE_DIR HAVE_EGL) +if(NOT EMSCRIPTEN) + list(APPEND required_vars EGL_LIBRARY) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(EGL + FOUND_VAR + EGL_FOUND + REQUIRED_VARS + ${required_vars} + VERSION_VAR + EGL_VERSION +) + +if(EGL_FOUND AND NOT TARGET EGL::EGL) + if (EMSCRIPTEN) + add_library(EGL::EGL INTERFACE IMPORTED) + # Nothing further to be done, system include paths have headers and linkage is implicit. + else() + add_library(EGL::EGL UNKNOWN IMPORTED) + set_target_properties(EGL::EGL PROPERTIES + IMPORTED_LOCATION "${EGL_LIBRARY}" + INTERFACE_COMPILE_OPTIONS "${EGL_DEFINITIONS}" + INTERFACE_INCLUDE_DIRECTORIES "${EGL_INCLUDE_DIR}" + ) + endif() +endif() + +mark_as_advanced(EGL_LIBRARY EGL_INCLUDE_DIR HAVE_EGL) + +# compatibility variables +set(EGL_LIBRARIES ${EGL_LIBRARY}) +set(EGL_INCLUDE_DIRS ${EGL_INCLUDE_DIR}) +set(EGL_VERSION_STRING ${EGL_VERSION}) + +include(FeatureSummary) +set_package_properties(EGL PROPERTIES + URL "https://www.khronos.org/egl/" + DESCRIPTION "A platform-independent mechanism for creating rendering surfaces for use with other graphics libraries, such as OpenGL|ES and OpenVG." +) diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/cmake/FindJsonCpp.cmake b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/FindJsonCpp.cmake new file mode 100644 index 0000000..2a32112 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/FindJsonCpp.cmake @@ -0,0 +1,395 @@ +# - Find jsoncpp - Overarching find module +# This is a over-arching find module to find older jsoncpp versions and those sadly built +# without JSONCPP_WITH_CMAKE_PACKAGE=ON, as well as those built with the cmake config file. +# It also wraps the different versions of the module. +# +# On CMake 3.0 and newer: +# JsonCpp::JsonCpp - Imported target (possibly an interface/alias) to use: +# if anything is populated, this is. If both shared and static are found, then +# this will be the static version on DLL platforms and shared on non-DLL platforms. +# JsonCpp::JsonCppShared - Imported target (possibly an interface/alias) for a +# shared library version. +# JsonCpp::JsonCppStatic - Imported target (possibly an interface/alias) for a +# static library version. +# +# On all CMake versions: (Note that on CMake 2.8.10 and earlier, you may need to use JSONCPP_INCLUDE_DIRS) +# JSONCPP_LIBRARY - wraps JsonCpp::JsonCpp or equiv. +# JSONCPP_LIBRARY_IS_SHARED - if we know for sure JSONCPP_LIBRARY is shared, this is true-ish. We try to "un-set" it if we don't know one way or another. +# JSONCPP_LIBRARY_SHARED - wraps JsonCpp::JsonCppShared or equiv. +# JSONCPP_LIBRARY_STATIC - wraps JsonCpp::JsonCppStatic or equiv. +# JSONCPP_INCLUDE_DIRS - Include directories - should (generally?) not needed if you require CMake 2.8.11+ since it handles target include directories. +# +# JSONCPP_FOUND - True if JsonCpp was found. +# +# Original Author: +# 2016 Rylie Pavlik <rylie@ryliepavlik.com> +# Incorporates work from the module contributed to VRPN under the same license: +# 2011 Philippe Crassous (ENSAM ParisTech / Institut Image) p.crassous _at_ free.fr +# +# Copyright 2011, Philippe Crassous +# Copyright 2016, Sensics, Inc. +# +# SPDX-License-Identifier: BSL-1.0 +# +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt) + +set(__jsoncpp_have_namespaced_targets OFF) +set(__jsoncpp_have_interface_support OFF) +if(NOT ("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 3.0)) + set(__jsoncpp_have_namespaced_targets ON) + set(__jsoncpp_have_interface_support ON) +elseif(("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" EQUAL 2.8) AND "${CMAKE_PATCH_VERSION}" GREATER 10) + set(__jsoncpp_have_interface_support ON) +endif() + +# sets __jsoncpp_have_jsoncpplib based on whether or not we have a real imported jsoncpp_lib target. +macro(_jsoncpp_check_for_real_jsoncpplib) + set(__jsoncpp_have_jsoncpplib FALSE) + if(TARGET jsoncpp_lib) + get_property(__jsoncpp_lib_type TARGET jsoncpp_lib PROPERTY TYPE) + # We make interface libraries. If an actual config module made it, it would be an imported library. + if(NOT __jsoncpp_lib_type STREQUAL "INTERFACE_LIBRARY") + set(__jsoncpp_have_jsoncpplib TRUE) + endif() + endif() + #message(STATUS "__jsoncpp_have_jsoncpplib ${__jsoncpp_have_jsoncpplib}") +endmacro() + +include(FindPackageHandleStandardArgs) +# Ensure that if this is TRUE later, it's because we set it. +set(JSONCPP_FOUND FALSE) +set(__jsoncpp_have_jsoncpplib FALSE) + +# See if we find a CMake config file - there is no harm in calling this more than once, +# and we need to call it at least once every CMake invocation to create the original +# imported targets, since those don't stick around like cache variables. +find_package(jsoncpp QUIET NO_MODULE) + +if(jsoncpp_FOUND) + # Build a string to help us figure out when to invalidate our cache variables. + # start with where we found jsoncpp + set(__jsoncpp_info_string "[${jsoncpp_DIR}]") + + # part of the string to indicate if we found a real jsoncpp_lib (and what kind) + _jsoncpp_check_for_real_jsoncpplib() + + macro(_jsoncpp_apply_map_config target) + if(MSVC) + # Can't do this - different runtimes, incompatible ABI, etc. + set(_jsoncpp_debug_fallback) + else() + set(_jsoncpp_debug_fallback DEBUG) + #osvr_stash_map_config(DEBUG DEBUG RELWITHDEBINFO RELEASE MINSIZEREL NONE) + endif() + # Appending, just in case using project or upstream fixes this. + set_property(TARGET ${target} APPEND PROPERTY MAP_IMPORTED_CONFIG_RELEASE RELEASE RELWITHDEBINFO MINSIZEREL NONE ${_jsoncpp_debug_fallback}) + set_property(TARGET ${target} APPEND PROPERTY MAP_IMPORTED_CONFIG_RELWITHDEBINFO RELWITHDEBINFO RELEASE MINSIZEREL NONE ${_jsoncpp_debug_fallback}) + set_property(TARGET ${target} APPEND PROPERTY MAP_IMPORTED_CONFIG_MINSIZEREL MINSIZEREL RELEASE RELWITHDEBINFO NONE ${_jsoncpp_debug_fallback}) + set_property(TARGET ${target} APPEND PROPERTY MAP_IMPORTED_CONFIG_NONE NONE RELEASE RELWITHDEBINFO MINSIZEREL ${_jsoncpp_debug_fallback}) + if(NOT MSVC) + set_property(TARGET ${target} APPEND PROPERTY MAP_IMPORTED_CONFIG_DEBUG DEBUG RELWITHDEBINFO RELEASE MINSIZEREL NONE) + endif() + endmacro() + if(__jsoncpp_have_jsoncpplib) + list(APPEND __jsoncpp_info_string "[${__jsoncpp_lib_type}]") + _jsoncpp_apply_map_config(jsoncpp_lib) + else() + list(APPEND __jsoncpp_info_string "[]") + endif() + # part of the string to indicate if we found jsoncpp_lib_static + if(TARGET jsoncpp_lib_static) + list(APPEND __jsoncpp_info_string "[T]") + _jsoncpp_apply_map_config(jsoncpp_lib_static) + else() + list(APPEND __jsoncpp_info_string "[]") + endif() +endif() + + +# If we found something, and it's not the exact same as what we've found before... +# NOTE: The contents of this "if" block update only (internal) cache variables! +# (since this will only get run the first CMake pass that finds jsoncpp or that finds a different/updated install) +if(jsoncpp_FOUND AND NOT __jsoncpp_info_string STREQUAL "${JSONCPP_CACHED_JSONCPP_DIR_DETAILS}") + #message("Updating jsoncpp cache variables! ${__jsoncpp_info_string}") + set(JSONCPP_CACHED_JSONCPP_DIR_DETAILS "${__jsoncpp_info_string}" CACHE INTERNAL "" FORCE) + unset(JSONCPP_IMPORTED_LIBRARY_SHARED) + unset(JSONCPP_IMPORTED_LIBRARY_STATIC) + unset(JSONCPP_IMPORTED_LIBRARY) + unset(JSONCPP_IMPORTED_INCLUDE_DIRS) + unset(JSONCPP_IMPORTED_LIBRARY_IS_SHARED) + + # if(__jsoncpp_have_jsoncpplib) is equivalent to if(TARGET jsoncpp_lib) except it excludes our + # "invented" jsoncpp_lib interface targets, made for convenience purposes after this block. + + if(__jsoncpp_have_jsoncpplib AND TARGET jsoncpp_lib_static) + + # A veritable cache of riches - we have both shared and static! + set(JSONCPP_IMPORTED_LIBRARY_SHARED jsoncpp_lib CACHE INTERNAL "" FORCE) + set(JSONCPP_IMPORTED_LIBRARY_STATIC jsoncpp_lib_static CACHE INTERNAL "" FORCE) + if(WIN32 OR CYGWIN OR MINGW) + # DLL platforms: static library should be default + set(JSONCPP_IMPORTED_LIBRARY ${JSONCPP_IMPORTED_LIBRARY_STATIC} CACHE INTERNAL "" FORCE) + set(JSONCPP_IMPORTED_LIBRARY_IS_SHARED FALSE CACHE INTERNAL "" FORCE) + else() + # Other platforms - might require PIC to be linked into shared libraries, so safest to prefer shared. + set(JSONCPP_IMPORTED_LIBRARY ${JSONCPP_IMPORTED_LIBRARY_SHARED} CACHE INTERNAL "" FORCE) + set(JSONCPP_IMPORTED_LIBRARY_IS_SHARED TRUE CACHE INTERNAL "" FORCE) + endif() + + elseif(TARGET jsoncpp_lib_static) + # Well, only one variant, but we know for sure that it's static. + set(JSONCPP_IMPORTED_LIBRARY_STATIC jsoncpp_lib_static CACHE INTERNAL "" FORCE) + set(JSONCPP_IMPORTED_LIBRARY jsoncpp_lib_static CACHE INTERNAL "" FORCE) + set(JSONCPP_IMPORTED_LIBRARY_IS_SHARED FALSE CACHE INTERNAL "" FORCE) + + elseif(__jsoncpp_have_jsoncpplib AND __jsoncpp_lib_type STREQUAL "STATIC_LIBRARY") + # We were able to figure out the mystery library is static! + set(JSONCPP_IMPORTED_LIBRARY_STATIC jsoncpp_lib CACHE INTERNAL "" FORCE) + set(JSONCPP_IMPORTED_LIBRARY jsoncpp_lib CACHE INTERNAL "" FORCE) + set(JSONCPP_IMPORTED_LIBRARY_IS_SHARED FALSE CACHE INTERNAL "" FORCE) + + elseif(__jsoncpp_have_jsoncpplib AND __jsoncpp_lib_type STREQUAL "SHARED_LIBRARY") + # We were able to figure out the mystery library is shared! + set(JSONCPP_IMPORTED_LIBRARY_SHARED jsoncpp_lib CACHE INTERNAL "" FORCE) + set(JSONCPP_IMPORTED_LIBRARY jsoncpp_lib CACHE INTERNAL "" FORCE) + set(JSONCPP_IMPORTED_LIBRARY_IS_SHARED TRUE CACHE INTERNAL "" FORCE) + + elseif(__jsoncpp_have_jsoncpplib) + # One variant, and we have no idea if this is just an old version or if + # this is shared based on the target name alone. Hmm. + set(JSONCPP_IMPORTED_LIBRARY jsoncpp_lib CACHE INTERNAL "" FORCE) + endif() + + # Now, we need include directories. Can't just limit this to old CMakes, since + # new CMakes might be used to build projects designed to support older ones. + if(__jsoncpp_have_jsoncpplib) + get_property(__jsoncpp_interface_include_dirs TARGET jsoncpp_lib PROPERTY INTERFACE_INCLUDE_DIRECTORIES) + if(__jsoncpp_interface_include_dirs) + set(JSONCPP_IMPORTED_INCLUDE_DIRS "${__jsoncpp_interface_include_dirs}" CACHE INTERNAL "" FORCE) + endif() + endif() + if(TARGET jsoncpp_lib_static AND NOT JSONCPP_IMPORTED_INCLUDE_DIRS) + get_property(__jsoncpp_interface_include_dirs TARGET jsoncpp_lib_static PROPERTY INTERFACE_INCLUDE_DIRECTORIES) + if(__jsoncpp_interface_include_dirs) + set(JSONCPP_IMPORTED_INCLUDE_DIRS "${__jsoncpp_interface_include_dirs}" CACHE INTERNAL "" FORCE) + endif() + endif() +endif() + +# As a convenience... +if(TARGET jsoncpp_lib_static AND NOT TARGET jsoncpp_lib) + add_library(jsoncpp_lib INTERFACE) + target_link_libraries(jsoncpp_lib INTERFACE jsoncpp_lib_static) +endif() + +if(JSONCPP_IMPORTED_LIBRARY) + if(NOT JSONCPP_IMPORTED_INCLUDE_DIRS) + # OK, so we couldn't get it from the target... maybe we can figure it out from jsoncpp_DIR. + + # take off the jsoncpp component + get_filename_component(__jsoncpp_import_root "${jsoncpp_DIR}/.." ABSOLUTE) + set(__jsoncpp_hints "${__jsoncpp_import_root}") + # take off the cmake component + get_filename_component(__jsoncpp_import_root "${__jsoncpp_import_root}/.." ABSOLUTE) + list(APPEND __jsoncpp_hints "${__jsoncpp_import_root}") + # take off the lib component + get_filename_component(__jsoncpp_import_root "${__jsoncpp_import_root}/.." ABSOLUTE) + list(APPEND __jsoncpp_hints "${__jsoncpp_import_root}") + # take off one more component in case of multiarch lib + get_filename_component(__jsoncpp_import_root "${__jsoncpp_import_root}/.." ABSOLUTE) + list(APPEND __jsoncpp_hints "${__jsoncpp_import_root}") + + # Now, search. + find_path(JsonCpp_INCLUDE_DIR + NAMES + json/json.h + PATH_SUFFIXES include jsoncpp include/jsoncpp + HINTS ${__jsoncpp_hints}) + if(JsonCpp_INCLUDE_DIR) + mark_as_advanced(JsonCpp_INCLUDE_DIR) + # Note - this does not set it in the cache, in case we find it better at some point in the future! + set(JSONCPP_IMPORTED_INCLUDE_DIRS ${JsonCpp_INCLUDE_DIR}) + endif() + endif() + + find_package_handle_standard_args(JsonCpp + DEFAULT_MSG + jsoncpp_DIR + JSONCPP_IMPORTED_LIBRARY + JSONCPP_IMPORTED_INCLUDE_DIRS) +endif() + +if(JSONCPP_FOUND) + # Create any missing namespaced targets from the config module. + if(__jsoncpp_have_namespaced_targets) + if(JSONCPP_IMPORTED_LIBRARY AND NOT TARGET JsonCpp::JsonCpp) + add_library(JsonCpp::JsonCpp INTERFACE IMPORTED) + set_target_properties(JsonCpp::JsonCpp PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${JSONCPP_IMPORTED_INCLUDE_DIRS}" + INTERFACE_LINK_LIBRARIES "${JSONCPP_IMPORTED_LIBRARY}") + endif() + + if(JSONCPP_IMPORTED_LIBRARY_SHARED AND NOT TARGET JsonCpp::JsonCppShared) + add_library(JsonCpp::JsonCppShared INTERFACE IMPORTED) + set_target_properties(JsonCpp::JsonCppShared PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${JSONCPP_IMPORTED_INCLUDE_DIRS}" + INTERFACE_LINK_LIBRARIES "${JSONCPP_IMPORTED_LIBRARY_SHARED}") + endif() + + if(JSONCPP_IMPORTED_LIBRARY_STATIC AND NOT TARGET JsonCpp::JsonCppStatic) + add_library(JsonCpp::JsonCppStatic INTERFACE IMPORTED) + set_target_properties(JsonCpp::JsonCppStatic PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${JSONCPP_IMPORTED_INCLUDE_DIRS}" + INTERFACE_LINK_LIBRARIES "${JSONCPP_IMPORTED_LIBRARY_STATIC}") + endif() + + # Hide the stuff we didn't, and no longer, need. + if(NOT JsonCpp_LIBRARY) + unset(JsonCpp_LIBRARY CACHE) + endif() + if(NOT JsonCpp_INCLUDE_DIR) + unset(JsonCpp_INCLUDE_DIR CACHE) + endif() + endif() + + set(JSONCPP_LIBRARY ${JSONCPP_IMPORTED_LIBRARY}) + set(JSONCPP_INCLUDE_DIRS ${JSONCPP_IMPORTED_INCLUDE_DIRS}) + if(DEFINED JSONCPP_IMPORTED_LIBRARY_IS_SHARED) + set(JSONCPP_LIBRARY_IS_SHARED ${JSONCPP_IMPORTED_LIBRARY_IS_SHARED}) + else() + unset(JSONCPP_LIBRARY_IS_SHARED) + endif() + + if(JSONCPP_IMPORTED_LIBRARY_SHARED) + set(JSONCPP_LIBRARY_SHARED ${JSONCPP_IMPORTED_LIBRARY_SHARED}) + endif() + + if(JSONCPP_IMPORTED_LIBRARY_STATIC) + set(JSONCPP_LIBRARY_STATIC ${JSONCPP_IMPORTED_LIBRARY_STATIC}) + endif() +endif() + +# Still nothing after looking for the config file: must go "old-school" +if(NOT JSONCPP_FOUND) + # Invoke pkgconfig for hints + find_package(PkgConfig QUIET) + set(_JSONCPP_INCLUDE_HINTS) + set(_JSONCPP_LIB_HINTS) + if(PKG_CONFIG_FOUND) + pkg_search_module(_JSONCPP_PC QUIET jsoncpp) + if(_JSONCPP_PC_INCLUDE_DIRS) + set(_JSONCPP_INCLUDE_HINTS ${_JSONCPP_PC_INCLUDE_DIRS}) + endif() + if(_JSONCPP_PC_LIBRARY_DIRS) + set(_JSONCPP_LIB_HINTS ${_JSONCPP_PC_LIBRARY_DIRS}) + endif() + if(_JSONCPP_PC_LIBRARIES) + set(_JSONCPP_LIB_NAMES ${_JSONCPP_PC_LIBRARIES}) + endif() + endif() + + if(NOT _JSONCPP_LIB_NAMES) + # OK, if pkg-config wasn't able to give us a library name suggestion, then we may + # have to resort to some intense old logic. + set(_JSONCPP_LIB_NAMES jsoncpp) + set(_JSONCPP_PATHSUFFIXES) + + if(CMAKE_SYSTEM_NAME STREQUAL "Linux") + list(APPEND _JSONCPP_PATHSUFFIXES + linux-gcc) # bit of a generalization but close... + endif() + if(CMAKE_COMPILER_IS_GNUCXX AND CMAKE_SYSTEM_NAME STREQUAL "Linux") + list(APPEND + _JSONCPP_LIB_NAMES + json_linux-gcc-${CMAKE_CXX_COMPILER_VERSION}_libmt + json_linux-gcc_libmt) + list(APPEND _JSONCPP_PATHSUFFIXES + linux-gcc-${CMAKE_CXX_COMPILER_VERSION}) + + elseif(MSVC) + if(MSVC_VERSION EQUAL 1200) + list(APPEND _JSONCPP_LIB_NAMES json_vc6_libmt) + list(APPEND _JSONCPP_PATHSUFFIXES msvc6) + elseif(MSVC_VERSION EQUAL 1300) + list(APPEND _JSONCPP_LIB_NAMES json_vc7_libmt) + list(APPEND _JSONCPP_PATHSUFFIXES msvc7) + elseif(MSVC_VERSION EQUAL 1310) + list(APPEND _JSONCPP_LIB_NAMES json_vc71_libmt) + list(APPEND _JSONCPP_PATHSUFFIXES msvc71) + elseif(MSVC_VERSION EQUAL 1400) + list(APPEND _JSONCPP_LIB_NAMES json_vc8_libmt) + list(APPEND _JSONCPP_PATHSUFFIXES msvc80) + elseif(MSVC_VERSION EQUAL 1500) + list(APPEND _JSONCPP_LIB_NAMES json_vc9_libmt) + list(APPEND _JSONCPP_PATHSUFFIXES msvc90) + elseif(MSVC_VERSION EQUAL 1600) + list(APPEND _JSONCPP_LIB_NAMES json_vc10_libmt) + list(APPEND _JSONCPP_PATHSUFFIXES msvc10 msvc100) + endif() + + elseif(MINGW) + list(APPEND _JSONCPP_LIB_NAMES + json_mingw_libmt) + list(APPEND _JSONCPP_PATHSUFFIXES mingw) + + else() + list(APPEND _JSONCPP_LIB_NAMES + json_suncc_libmt + json_vacpp_libmt) + endif() + endif() # end of old logic + + # Actually go looking. + find_path(JsonCpp_INCLUDE_DIR + NAMES + json/json.h + PATH_SUFFIXES jsoncpp + HINTS ${_JSONCPP_INCLUDE_HINTS}) + find_library(JsonCpp_LIBRARY + NAMES + ${_JSONCPP_LIB_NAMES} + PATHS libs + PATH_SUFFIXES ${_JSONCPP_PATHSUFFIXES} + HINTS ${_JSONCPP_LIB_HINTS}) + + find_package_handle_standard_args(JsonCpp + DEFAULT_MSG + JsonCpp_INCLUDE_DIR + JsonCpp_LIBRARY) + + if(JSONCPP_FOUND) + # We already know that the target doesn't exist, let's make it. + # TODO don't know why we get errors like: + # error: 'JsonCpp::JsonCpp-NOTFOUND', needed by 'bin/osvr_json_to_c', missing and no known rule to make it + # when we do the imported target commented out below. So, instead, we make an interface + # target with an alias. Hmm. + + #add_library(JsonCpp::JsonCpp UNKNOWN IMPORTED) + #set_target_properties(JsonCpp::JsonCpp PROPERTIES + # IMPORTED_LOCATION "${JsonCpp_LIBRARY}" + # INTERFACE_INCLUDE_DIRECTORIES "${JsonCpp_INCLUDE_DIR}" + # IMPORTED_LINK_INTERFACE_LANGUAGES "CXX") + + set(JSONCPP_LIBRARY "${JsonCpp_LIBRARY}") + set(JSONCPP_INCLUDE_DIRS "${JsonCpp_INCLUDE_DIR}") + unset(JSONCPP_LIBRARY_IS_SHARED) + + if(__jsoncpp_have_interface_support AND NOT TARGET jsoncpp_interface) + add_library(jsoncpp_interface INTERFACE) + set_target_properties(jsoncpp_interface PROPERTIES + INTERFACE_LINK_LIBRARIES "${JsonCpp_LIBRARY}" + INTERFACE_INCLUDE_DIRECTORIES "${JsonCpp_INCLUDE_DIR}") + endif() + if(__jsoncpp_have_namespaced_targets) + if(NOT TARGET JsonCpp::JsonCpp) + add_library(JsonCpp::JsonCpp ALIAS jsoncpp_interface) + endif() + endif() + endif() +endif() + +if(JSONCPP_FOUND) + mark_as_advanced(jsoncpp_DIR JsonCpp_INCLUDE_DIR JsonCpp_LIBRARY) +endif() diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/cmake/FindMetalTools.cmake b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/FindMetalTools.cmake new file mode 100644 index 0000000..20fe9b3 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/FindMetalTools.cmake @@ -0,0 +1,70 @@ +# Copyright 2024, Collabora, Ltd. +# +# SPDX-License-Identifier: BSL-1.0 +# +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt) +# +# Original Author: +# 2024 Rylie Pavlik <rylie.pavlik@collabora.com> <rylie@ryliepavlik.com> + +#.rst: +# FindMetalTools +# --------------- +# +# Find the ``metal`` and ``metallib`` tools via xcode. +# +# Cache variables +# ^^^^^^^^^^^^^^^ +# +# ``MetalTools_METAL_EXECUTABLE`` +# +# ``MetalTools_METALLIB_EXECUTABLE`` +# +# The following cache variable may also be set to assist/control the operation of this module: +# +# ``MetalTools_ROOT_DIR`` +# The root to search for MetalTools. + +if(NOT APPLE) + return() +endif() + +# Use xcrun to locate the tools +if(NOT MetalTools_METAL_EXECUTABLE) + execute_process( + COMMAND xcrun --find --sdk macosx metal + OUTPUT_VARIABLE MetalTools_METAL_EXECUTABLE_HINT + ) + get_filename_component( + MetalTools_METAL_HINT_DIR "${MetalTools_METAL_EXECUTABLE_HINT}" PATH + ) +endif() +if(NOT MetalTools_METALLIB_EXECUTABLE) + execute_process( + COMMAND xcrun --find --sdk macosx metallib + OUTPUT_VARIABLE MetalTools_METALLIB_EXECUTABLE_HINT + ) + get_filename_component( + MetalTools_METALLIB_HINT_DIR "${MetalTools_METALLIB_EXECUTABLE_HINT}" + PATH + ) +endif() + +find_program( + MetalTools_METAL_EXECUTABLE metal + HINTS "${MetalTools_METAL_HINT_DIR}" + PATHS "${MetalTools_ROOT_DIR}" +) + +find_program( + MetalTools_METALLIB_EXECUTABLE metallib + HINTS "${MetalTools_METALLIB_HINT_DIR}" + PATHS "${MetalTools_ROOT_DIR}" +) + +find_package_handle_standard_args( + MetalTools REQUIRED_VARS MetalTools_METAL_EXECUTABLE + MetalTools_METALLIB_EXECUTABLE +) diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/cmake/FindOpenGLES.cmake b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/FindOpenGLES.cmake new file mode 100644 index 0000000..bd63015 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/FindOpenGLES.cmake @@ -0,0 +1,260 @@ +# Copyright 2020-2021 Collabora, Ltd. +# SPDX-License-Identifier: BSL-1.0 +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt) +# +# Original Author: +# 2020-2021, Rylie Pavlik <rylie.pavlik@collabora.com> <rylie@ryliepavlik.com> + +#[[.rst: +FindOpenGLES +--------------- + +Find the OpenGL ES graphics API. + +Components +^^^^^^^^^^ + +The following components are supported: + +* ``V1`` - OpenGL ES 1 (including emulation on OpenGL ES 2) +* ``V2`` - OpenGL ES 2 +* ``V3`` - OpenGL ES 3 +* ``V31` - OpenGL ES 3.1 - same as 3 but checking also for gl31.h +* ``V32` - OpenGL ES 3.2 - same as 3 but checking also for gl32.h + +If none are specified, the default is ``V2``. + +Targets +^^^^^^^ + +If successful, some subset of the following imported targets are created. + +* ``OpenGLES::OpenGLESv1`` +* ``OpenGLES::OpenGLESv2`` +* ``OpenGLES::OpenGLESv3`` +* ``OpenGLES::OpenGLESv31`` +* ``OpenGLES::OpenGLESv32`` + +Cache variables +^^^^^^^^^^^^^^^ + +The following cache variable may also be set to assist/control the operation of this module: + +``OpenGLES_ROOT_DIR`` + The root to search for OpenGLES. +#]] + +set(OpenGLES_ROOT_DIR + "${OpenGLES_ROOT_DIR}" + CACHE PATH "Root to search for OpenGLES") + +if(NOT OpenGLES_FIND_COMPONENTS) + set(OpenGLES_FIND_COMPONENTS V2) +endif() + +if(NOT ANDROID) + find_package(PkgConfig QUIET) + if(PKG_CONFIG_FOUND) + set(_old_prefix_path "${CMAKE_PREFIX_PATH}") + # So pkg-config uses OpenGLES_ROOT_DIR too. + if(OpenGLES_ROOT_DIR) + list(APPEND CMAKE_PREFIX_PATH ${OpenGLES_ROOT_DIR}) + endif() + pkg_check_modules(PC_glesv1_cm QUIET glesv1_cm) + pkg_check_modules(PC_glesv2 QUIET glesv2) + # Restore + set(CMAKE_PREFIX_PATH "${_old_prefix_path}") + endif() +endif() + +find_path( + OpenGLES_V1_INCLUDE_DIR + NAMES GLES/gl.h + PATHS ${OpenGLES_ROOT_DIR} + HINTS ${PC_glesv2_INCLUDE_DIRS} ${PC_glesv1_cm_INCLUDE_DIRS} + PATH_SUFFIXES include) +find_path( + OpenGLES_V2_INCLUDE_DIR + NAMES GLES2/gl2.h + PATHS ${OpenGLES_ROOT_DIR} + HINTS ${PC_glesv2_INCLUDE_DIRS} ${PC_glesv1_cm_INCLUDE_DIRS} + PATH_SUFFIXES include) +find_path( + OpenGLES_V3_INCLUDE_DIR + NAMES GLES3/gl3.h + PATHS ${OpenGLES_ROOT_DIR} + HINTS ${OpenGLES_V1_INCLUDE_DIR} ${OpenGLES_V2_INCLUDE_DIR} + ${PC_glesv2_INCLUDE_DIRS} ${PC_glesv1_cm_INCLUDE_DIRS} + PATH_SUFFIXES include) +find_path( + OpenGLES_V31_INCLUDE_DIR + NAMES GLES3/gl31.h + PATHS ${OpenGLES_ROOT_DIR} + HINTS ${OpenGLES_V1_INCLUDE_DIR} ${OpenGLES_V2_INCLUDE_DIR} + ${OpenGLES_V3_INCLUDE_DIR} ${PC_glesv2_INCLUDE_DIRS} + ${PC_glesv1_cm_INCLUDE_DIRS} + PATH_SUFFIXES include) +find_path( + OpenGLES_V32_INCLUDE_DIR + NAMES GLES3/gl32.h + PATHS ${OpenGLES_ROOT_DIR} + HINTS ${OpenGLES_V1_INCLUDE_DIR} ${OpenGLES_V2_INCLUDE_DIR} + ${OpenGLES_V3_INCLUDE_DIR} ${OpenGLES_V31_INCLUDE_DIR} + ${PC_glesv2_INCLUDE_DIRS} ${PC_glesv1_cm_INCLUDE_DIRS} + PATH_SUFFIXES include) + +find_library( + OpenGLES_V1_LIBRARY + NAMES GLES GLESv1_CM + PATHS ${OpenGLES_ROOT_DIR} + HINTS ${PC_glesv1_cm_LIBRARY_DIRS} + PATH_SUFFIXES lib) +find_library( + OpenGLES_V2_LIBRARY + NAMES GLESv2 OpenGLES # for Apple framework + PATHS ${OpenGLES_ROOT_DIR} + HINTS ${PC_glesv2_LIBRARY_DIRS} + PATH_SUFFIXES lib) +find_library( + OpenGLES_V3_LIBRARY + NAMES GLESv3 + PATHS ${OpenGLES_ROOT_DIR} + HINTS ${PC_glesv2_LIBRARY_DIRS} + PATH_SUFFIXES lib) + +if(OpenGLES_V2_LIBRARY AND NOT OpenGLES_V3_LIBRARY) + set(OpenGLES_V3_LIBRARY ${OpenGLES_V2_LIBRARY}) +endif() + +set(_gles_required_vars) +foreach(_comp IN LISTS OpenGLES_FIND_COMPONENTS) + if(_comp STREQUAL "V1") + list(APPEND _gles_required_vars OpenGLES_V1_LIBRARY + OpenGLES_V1_INCLUDE_DIR) + if(OpenGLES_V1_INCLUDE_DIR AND OpenGLES_V1_LIBRARY) + set(OpenGLES_${_comp}_FOUND TRUE) + else() + set(OpenGLES_${_comp}_FOUND FALSE) + endif() + elseif(_comp STREQUAL "V2") + list(APPEND _gles_required_vars OpenGLES_V2_LIBRARY + OpenGLES_V2_INCLUDE_DIR) + if(OpenGLES_V2_INCLUDE_DIR AND OpenGLES_V2_LIBRARY) + set(OpenGLES_${_comp}_FOUND TRUE) + else() + set(OpenGLES_${_comp}_FOUND FALSE) + endif() + elseif(_comp STREQUAL "V3") + list(APPEND _gles_required_vars OpenGLES_V3_LIBRARY + OpenGLES_V3_INCLUDE_DIR) + if(OpenGLES_V3_INCLUDE_DIR AND OpenGLES_V3_LIBRARY) + set(OpenGLES_${_comp}_FOUND TRUE) + else() + set(OpenGLES_${_comp}_FOUND FALSE) + endif() + elseif(_comp STREQUAL "V31") + list(APPEND _gles_required_vars OpenGLES_V3_LIBRARY + OpenGLES_V31_INCLUDE_DIR) + + if(OpenGLES_V31_INCLUDE_DIR AND OpenGLES_V3_LIBRARY) + set(OpenGLES_${_comp}_FOUND TRUE) + else() + set(OpenGLES_${_comp}_FOUND FALSE) + endif() + elseif(_comp STREQUAL "V32") + list(APPEND _gles_required_vars OpenGLES_V3_LIBRARY + OpenGLES_V32_INCLUDE_DIR) + if(OpenGLES_V32_INCLUDE_DIR AND OpenGLES_V3_LIBRARY) + set(OpenGLES_${_comp}_FOUND TRUE) + else() + set(OpenGLES_${_comp}_FOUND FALSE) + endif() + else() + message( + WARNING "${_comp} is not a recognized OpenGL-ES component/version") + set(OpenGLES_${_comp}_FOUND FALSE) + endif() +endforeach() +if(_gles_required_vars) + list(REMOVE_DUPLICATES _gles_required_vars) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args( + OpenGLES + REQUIRED_VARS ${_gles_required_vars} + HANDLE_COMPONENTS) +if(OpenGLES_FOUND) + if(OpenGLES_V1_FOUND AND NOT TARGET OpenGLES::OpenGLESv1) + add_library(OpenGLES::OpenGLESv1 SHARED IMPORTED) + + set_target_properties( + OpenGLES::OpenGLESv1 + PROPERTIES INTERFACE_INCLUDE_DIRECTORIES + "${OpenGLES_V1_INCLUDE_DIR}" + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION ${OpenGLES_V1_LIBRARY}) + endif() + if(OpenGLES_V2_FOUND AND NOT TARGET OpenGLES::OpenGLESv2) + add_library(OpenGLES::OpenGLESv2 SHARED IMPORTED) + + set_target_properties( + OpenGLES::OpenGLESv2 + PROPERTIES INTERFACE_INCLUDE_DIRECTORIES + "${OpenGLES_V2_INCLUDE_DIR}" + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION ${OpenGLES_V2_LIBRARY}) + endif() + if(OpenGLES_V3_FOUND) + if(NOT TARGET OpenGLES::OpenGLESv3) + add_library(OpenGLES::OpenGLESv3 SHARED IMPORTED) + + set_target_properties( + OpenGLES::OpenGLESv3 + PROPERTIES INTERFACE_INCLUDE_DIRECTORIES + "${OpenGLES_V3_INCLUDE_DIR}" + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION ${OpenGLES_V3_LIBRARY}) + endif() + if(OpenGLES_V31_FOUND AND NOT TARGET OpenGLES::OpenGLESv31) + add_library(OpenGLES::OpenGLESv31 SHARED IMPORTED) + + set_target_properties( + OpenGLES::OpenGLESv31 + PROPERTIES INTERFACE_INCLUDE_DIRECTORIES + "${OpenGLES_V31_INCLUDE_DIR}" + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION ${OpenGLES_V3_LIBRARY}) + endif() + if(OpenGLES_V32_FOUND AND NOT TARGET OpenGLES::OpenGLESv32) + add_library(OpenGLES::OpenGLESv32 SHARED IMPORTED) + + set_target_properties( + OpenGLES::OpenGLESv32 + PROPERTIES INTERFACE_INCLUDE_DIRECTORIES + "${OpenGLES_V32_INCLUDE_DIR}" + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION ${OpenGLES_V3_LIBRARY}) + endif() + endif() + mark_as_advanced( + OpenGLES_V1_LIBRARY + OpenGLES_V1_INCLUDE_DIR + OpenGLES_V2_LIBRARY + OpenGLES_V2_INCLUDE_DIR + OpenGLES_V3_LIBRARY + OpenGLES_V3_INCLUDE_DIR + OpenGLES_V31_INCLUDE_DIR + OpenGLES_V32_INCLUDE_DIR) +endif() +mark_as_advanced(OpenGLES_ROOT_DIR) + +include(FeatureSummary) +set_package_properties( + OpenGLES PROPERTIES + URL "https://www.khronos.org/opengles/" + DESCRIPTION + "A cross-platform graphics API, specialized for mobile and embedded, defined as a subset of desktop OpenGL." +) diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/cmake/GetGitRevisionDescription.cmake b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/GetGitRevisionDescription.cmake new file mode 100644 index 0000000..5a6765f --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/GetGitRevisionDescription.cmake @@ -0,0 +1,285 @@ +# - Returns a version string from Git +# +# These functions force a re-configure on each git commit so that you can +# trust the values of the variables in your build system. +# +# get_git_head_revision(<refspecvar> <hashvar> [ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR]) +# +# Returns the refspec and sha hash of the current head revision +# +# git_describe(<var> [<additional arguments to git describe> ...]) +# +# Returns the results of git describe on the source tree, and adjusting +# the output so that it tests false if an error occurs. +# +# git_describe_working_tree(<var> [<additional arguments to git describe> ...]) +# +# Returns the results of git describe on the working tree (--dirty option), +# and adjusting the output so that it tests false if an error occurs. +# +# git_get_exact_tag(<var> [<additional arguments to git describe> ...]) +# +# Returns the results of git describe --exact-match on the source tree, +# and adjusting the output so that it tests false if there was no exact +# matching tag. +# +# git_local_changes(<var>) +# +# Returns either "CLEAN" or "DIRTY" with respect to uncommitted changes. +# Uses the return code of "git diff-index --quiet HEAD --". +# Does not regard untracked files. +# +# Requires CMake 2.6 or newer (uses the 'function' command) +# +# Original Author: +# 2009-2020 Rylie Pavlik <rylie@ryliepavlik.com> +# https://ryliepavlik.com/ +# +# Copyright 2009-2013, Iowa State University. +# Copyright 2013-2020, Rylie Pavlik +# Copyright 2013-2020, Contributors +# SPDX-License-Identifier: BSL-1.0 +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt) + +if(__get_git_revision_description) + return() +endif() +set(__get_git_revision_description YES) + +# We must run the following at "include" time, not at function call time, +# to find the path to this module rather than the path to a calling list file +get_filename_component(_gitdescmoddir ${CMAKE_CURRENT_LIST_FILE} PATH) + +# Function _git_find_closest_git_dir finds the next closest .git directory +# that is part of any directory in the path defined by _start_dir. +# The result is returned in the parent scope variable whose name is passed +# as variable _git_dir_var. If no .git directory can be found, the +# function returns an empty string via _git_dir_var. +# +# Example: Given a path C:/bla/foo/bar and assuming C:/bla/.git exists and +# neither foo nor bar contain a file/directory .git. This will return +# C:/bla/.git +# +function(_git_find_closest_git_dir _start_dir _git_dir_var) + set(cur_dir "${_start_dir}") + set(git_dir "${_start_dir}/.git") + while(NOT EXISTS "${git_dir}") + # .git dir not found, search parent directories + set(git_previous_parent "${cur_dir}") + get_filename_component(cur_dir "${cur_dir}" DIRECTORY) + if(cur_dir STREQUAL git_previous_parent) + # We have reached the root directory, we are not in git + set(${_git_dir_var} + "" + PARENT_SCOPE) + return() + endif() + set(git_dir "${cur_dir}/.git") + endwhile() + set(${_git_dir_var} + "${git_dir}" + PARENT_SCOPE) +endfunction() + +function(get_git_head_revision _refspecvar _hashvar) + _git_find_closest_git_dir("${CMAKE_CURRENT_SOURCE_DIR}" GIT_DIR) + + if("${ARGN}" STREQUAL "ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR") + set(ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR TRUE) + else() + set(ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR FALSE) + endif() + if(NOT "${GIT_DIR}" STREQUAL "") + file(RELATIVE_PATH _relative_to_source_dir "${CMAKE_SOURCE_DIR}" + "${GIT_DIR}") + if("${_relative_to_source_dir}" MATCHES "[.][.]" + AND NOT ALLOW_LOOKING_ABOVE_CMAKE_SOURCE_DIR) + # We've gone above the CMake root dir. + set(GIT_DIR "") + endif() + endif() + if("${GIT_DIR}" STREQUAL "") + set(${_refspecvar} + "GITDIR-NOTFOUND" + PARENT_SCOPE) + set(${_hashvar} + "GITDIR-NOTFOUND" + PARENT_SCOPE) + return() + endif() + + # Check if the current source dir is a git submodule or a worktree. + # In both cases .git is a file instead of a directory. + # + if(NOT IS_DIRECTORY ${GIT_DIR}) + # The following git command will return a non empty string that + # points to the super project working tree if the current + # source dir is inside a git submodule. + # Otherwise the command will return an empty string. + # + execute_process( + COMMAND "${GIT_EXECUTABLE}" rev-parse + --show-superproject-working-tree + WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + OUTPUT_VARIABLE out + ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE) + if(NOT "${out}" STREQUAL "") + # If out is empty, GIT_DIR/CMAKE_CURRENT_SOURCE_DIR is in a submodule + file(READ ${GIT_DIR} submodule) + string(REGEX REPLACE "gitdir: (.*)$" "\\1" GIT_DIR_RELATIVE + ${submodule}) + string(STRIP ${GIT_DIR_RELATIVE} GIT_DIR_RELATIVE) + get_filename_component(SUBMODULE_DIR ${GIT_DIR} PATH) + get_filename_component(GIT_DIR ${SUBMODULE_DIR}/${GIT_DIR_RELATIVE} + ABSOLUTE) + set(HEAD_SOURCE_FILE "${GIT_DIR}/HEAD") + else() + # GIT_DIR/CMAKE_CURRENT_SOURCE_DIR is in a worktree + file(READ ${GIT_DIR} worktree_ref) + # The .git directory contains a path to the worktree information directory + # inside the parent git repo of the worktree. + # + string(REGEX REPLACE "gitdir: (.*)$" "\\1" git_worktree_dir + ${worktree_ref}) + string(STRIP ${git_worktree_dir} git_worktree_dir) + _git_find_closest_git_dir("${git_worktree_dir}" GIT_DIR) + set(HEAD_SOURCE_FILE "${git_worktree_dir}/HEAD") + endif() + else() + set(HEAD_SOURCE_FILE "${GIT_DIR}/HEAD") + endif() + set(GIT_DATA "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/git-data") + if(NOT EXISTS "${GIT_DATA}") + file(MAKE_DIRECTORY "${GIT_DATA}") + endif() + + if(NOT EXISTS "${HEAD_SOURCE_FILE}") + return() + endif() + set(HEAD_FILE "${GIT_DATA}/HEAD") + configure_file("${HEAD_SOURCE_FILE}" "${HEAD_FILE}" COPYONLY) + + configure_file("${_gitdescmoddir}/GetGitRevisionDescription.cmake.in" + "${GIT_DATA}/grabRef.cmake" @ONLY) + include("${GIT_DATA}/grabRef.cmake") + + set(${_refspecvar} + "${HEAD_REF}" + PARENT_SCOPE) + set(${_hashvar} + "${HEAD_HASH}" + PARENT_SCOPE) +endfunction() + +function(git_describe _var) + if(NOT GIT_FOUND) + find_package(Git QUIET) + endif() + get_git_head_revision(refspec hash) + if(NOT GIT_FOUND) + set(${_var} + "GIT-NOTFOUND" + PARENT_SCOPE) + return() + endif() + if(NOT hash) + set(${_var} + "HEAD-HASH-NOTFOUND" + PARENT_SCOPE) + return() + endif() + + # TODO sanitize + #if((${ARGN}" MATCHES "&&") OR + # (ARGN MATCHES "||") OR + # (ARGN MATCHES "\\;")) + # message("Please report the following error to the project!") + # message(FATAL_ERROR "Looks like someone's doing something nefarious with git_describe! Passed arguments ${ARGN}") + #endif() + + #message(STATUS "Arguments to execute_process: ${ARGN}") + + execute_process( + COMMAND "${GIT_EXECUTABLE}" describe --tags --always ${hash} ${ARGN} + WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + RESULT_VARIABLE res + OUTPUT_VARIABLE out + ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE) + if(NOT res EQUAL 0) + set(out "${out}-${res}-NOTFOUND") + endif() + + set(${_var} + "${out}" + PARENT_SCOPE) +endfunction() + +function(git_describe_working_tree _var) + if(NOT GIT_FOUND) + find_package(Git QUIET) + endif() + if(NOT GIT_FOUND) + set(${_var} + "GIT-NOTFOUND" + PARENT_SCOPE) + return() + endif() + + execute_process( + COMMAND "${GIT_EXECUTABLE}" describe --dirty ${ARGN} + WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + RESULT_VARIABLE res + OUTPUT_VARIABLE out + ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE) + if(NOT res EQUAL 0) + set(out "${out}-${res}-NOTFOUND") + endif() + + set(${_var} + "${out}" + PARENT_SCOPE) +endfunction() + +function(git_get_exact_tag _var) + git_describe(out --exact-match ${ARGN}) + set(${_var} + "${out}" + PARENT_SCOPE) +endfunction() + +function(git_local_changes _var) + if(NOT GIT_FOUND) + find_package(Git QUIET) + endif() + get_git_head_revision(refspec hash) + if(NOT GIT_FOUND) + set(${_var} + "GIT-NOTFOUND" + PARENT_SCOPE) + return() + endif() + if(NOT hash) + set(${_var} + "HEAD-HASH-NOTFOUND" + PARENT_SCOPE) + return() + endif() + + execute_process( + COMMAND "${GIT_EXECUTABLE}" diff-index --quiet HEAD -- + WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" + RESULT_VARIABLE res + OUTPUT_VARIABLE out + ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE) + if(res EQUAL 0) + set(${_var} + "CLEAN" + PARENT_SCOPE) + else() + set(${_var} + "DIRTY" + PARENT_SCOPE) + endif() +endfunction() diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/cmake/GetGitRevisionDescription.cmake.in b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/GetGitRevisionDescription.cmake.in new file mode 100644 index 0000000..0633566 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/GetGitRevisionDescription.cmake.in @@ -0,0 +1,46 @@ +# +# Internal file for GetGitRevisionDescription.cmake +# +# Requires CMake 2.6 or newer (uses the 'function' command) +# +# Original Author: +# 2009-2023 Rylie Pavlik <rylie@ryliepavlik.com> +# https://ryliepavlik.com/ +# Iowa State University HCI Graduate Program/VRAC +# +# Copyright 2009-2012, Iowa State University +# Copyright 2011-2023, Contributors +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt) +# SPDX-License-Identifier: BSL-1.0 + +set(HEAD_HASH) + +file(READ "@HEAD_FILE@" HEAD_CONTENTS LIMIT 1024) + +string(STRIP "${HEAD_CONTENTS}" HEAD_CONTENTS) +if(HEAD_CONTENTS MATCHES "ref") + # named branch + string(REPLACE "ref: " "" HEAD_REF "${HEAD_CONTENTS}") + if(EXISTS "@GIT_DIR@/${HEAD_REF}") + configure_file("@GIT_DIR@/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY) + else() + if(EXISTS "@GIT_DIR@/packed-refs") + configure_file("@GIT_DIR@/packed-refs" "@GIT_DATA@/packed-refs" + COPYONLY) + file(READ "@GIT_DATA@/packed-refs" PACKED_REFS) + if(${PACKED_REFS} MATCHES "([0-9a-z]*) ${HEAD_REF}") + set(HEAD_HASH "${CMAKE_MATCH_1}") + endif() + endif() + endif() +else() + # detached HEAD + configure_file("@GIT_DIR@/HEAD" "@GIT_DATA@/head-ref" COPYONLY) +endif() + +if(NOT HEAD_HASH) + file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024) + string(STRIP "${HEAD_HASH}" HEAD_HASH) +endif() diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/cmake/StdFilesystemFlags.cmake b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/StdFilesystemFlags.cmake new file mode 100644 index 0000000..7a80396 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/StdFilesystemFlags.cmake @@ -0,0 +1,183 @@ +# Copyright 2020, Collabora, Ltd. +# +# SPDX-License-Identifier: BSL-1.0 + +set(_FILESYSTEM_UTILS_DIR "${PROJECT_SOURCE_DIR}/src/common") + +if(MSVC AND MSVC_VERSION GREATER 1890) + set(HAVE_FILESYSTEM_WITHOUT_LIB + ON + CACHE INTERNAL "" FORCE + ) + if(MSVC_VERSION GREATER 1910) + # Visual Studio 2017 Update 3 added new filesystem impl, + # which only works in C++17 mode. + set(HAVE_FILESYSTEM_NEEDS_17 + ON + CACHE INTERNAL "" FORCE + ) + endif() +else() + include(CheckCXXSourceCompiles) + + ### + # Test Sources + ### + + # This is just example code that is known to not compile if std::filesystem isn't working right. + # It depends on having the proper includes and `using namespace` so it can use the `is_regular_file` + # function unqualified. + # It is at the end of every test file below. + set(_stdfs_test_source + "int main() { + (void)is_regular_file(\"/\"); + return 0; + } + " + ) + + # This is preprocessor code included in all test compiles, which pulls in the conditions + # originally found in filesystem_utils.cpp. + # + # It defines: + # USE_FINAL_FS = 1 if it thinks we have the full std::filesystem in <filesystem> as in C++17 + # USE_EXPERIMENTAL_FS = 1 if it thinks we don't have the full c++17 filesystem, but should have + # std::experimental::filesystem and <experimental/filesystem> + # + # Ideally the first condition (__cplusplus >= 201703L) would handle most cases, + # however you're not supposed to report that unless you're fully conformant with all + # of c++17, so you might have a c++17 build flag and the final filesystem library but + # a lower __cplusplus value if some other part of the standard is missing. + set(_stdfs_conditions "#include <stdfs_conditions.h> + ") + + # This should only compile if our common detection code decides on the + # **final** (non-experimental) filesystem library. + set(_stdfs_source + "${_stdfs_conditions} + #if defined(USE_FINAL_FS) && USE_FINAL_FS + #include <filesystem> + using namespace std::filesystem; + #endif + ${_stdfs_test_source} + " + ) + + # This should only compile if our common detection code decides on the + # **experimental** filesystem library. + set(_stdfs_experimental_source + "${_stdfs_conditions} + #if defined(USE_EXPERIMENTAL_FS) && USE_EXPERIMENTAL_FS + #include <experimental/filesystem> + using namespace std::experimental::filesystem; + #endif + ${_stdfs_test_source} + " + ) + + # This should compile if the common detection code decided that either + # the experimental or final filesystem library is available. + # We use this when trying to detect what library to link, if any: + # earlier checks are the ones that care about how we include the headers. + set(_stdfs_needlib_source + "${_stdfs_conditions} + #if defined(USE_FINAL_FS) && USE_FINAL_FS + #include <filesystem> + using namespace std::filesystem; + #endif + #if defined(USE_EXPERIMENTAL_FS) && USE_EXPERIMENTAL_FS + #include <experimental/filesystem> + using namespace std::experimental::filesystem; + #endif + ${_stdfs_test_source} + " + ) + + ### + # Identifying header/namespace and standards flags + ### + + # First, just look for the include. + # We're checking if it compiles, not if the include exists, + # because the source code uses the same conditionals to decide. + # (Static libraries are just object files, they don't get linked) + set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY) + set(CMAKE_REQUIRED_INCLUDES "${_FILESYSTEM_UTILS_DIR}") + unset(CMAKE_REQUIRED_LIBRARIES) + if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 11.0) + # GCC 11+ defaults to C++17 mode and acts badly in these tests if we tell it to use a different version. + set(HAVE_FILESYSTEM_IN_STD_17 ON) + set(HAVE_FILESYSTEM_IN_STD OFF) + else() + set(CMAKE_REQUIRED_FLAGS "-DCMAKE_CXX_STANDARD=17 -DCMAKE_CXX_STANDARD_REQUIRED=TRUE") + check_cxx_source_compiles("${_stdfs_source}" HAVE_FILESYSTEM_IN_STD) + check_cxx_source_compiles("${_stdfs_experimental_source}" HAVE_FILESYSTEM_IN_STDEXPERIMENTAL) + + # See if the "final" version builds if we try to specify C++17 explicitly + set(CMAKE_REQUIRED_FLAGS "-DCMAKE_CXX_STANDARD=17 -DCMAKE_CXX_STANDARD_REQUIRED=TRUE") + check_cxx_source_compiles("${_stdfs_source}" HAVE_FILESYSTEM_IN_STD_17) + unset(CMAKE_REQUIRED_FLAGS) + endif() + + # If we found the final version of filesystem when specifying C++17 explicitly, + # but found it no other way, then we record that we must use C++17 flags. + if(HAVE_FILESYSTEM_IN_STD_17 AND NOT HAVE_FILESYSTEM_IN_STD) + set(HAVE_FILESYSTEM_NEEDS_17 + ON + CACHE INTERNAL "" + ) + set(CMAKE_REQUIRED_FLAGS "-DCMAKE_CXX_STANDARD=17 -DCMAKE_CXX_STANDARD_REQUIRED=TRUE") + else() + set(HAVE_FILESYSTEM_NEEDS_17 + OFF + CACHE INTERNAL "" + ) + endif() + + ### + # Identifying library to link + ### + + # Now, see if we need to link against libstdc++fs, and what it's called + # If we needed C++17 standard flags to find it, they've already been set above. + set(CMAKE_TRY_COMPILE_TARGET_TYPE EXECUTABLE) + + # Try with no lib specified + check_cxx_source_compiles("${_stdfs_needlib_source}" HAVE_FILESYSTEM_WITHOUT_LIB) + + # Try with stdc++fs + set(CMAKE_REQUIRED_LIBRARIES stdc++fs) + check_cxx_source_compiles("${_stdfs_needlib_source}" HAVE_FILESYSTEM_NEEDING_LIBSTDCXXFS) + + # Try with c++fs (from clang's libc++) + set(CMAKE_REQUIRED_LIBRARIES c++fs) + check_cxx_source_compiles("${_stdfs_needlib_source}" HAVE_FILESYSTEM_NEEDING_LIBCXXFS) + + # Clean up these variables before the next user. + unset(CMAKE_REQUIRED_LIBRARIES) + unset(CMAKE_TRY_COMPILE_TARGET_TYPE) + unset(CMAKE_REQUIRED_INCLUDES) +endif() + +# Use the observations of the code above to add the filesystem_utils.cpp +# file to a target, along with any required compiler settings and libraries. +# Also handles our BUILD_WITH_STD_FILESYSTEM option. +function(openxr_add_filesystem_utils TARGET_NAME) + target_sources(${TARGET_NAME} PRIVATE ${_FILESYSTEM_UTILS_DIR}/filesystem_utils.cpp) + target_include_directories(${TARGET_NAME} PRIVATE ${_FILESYSTEM_UTILS_DIR}) + if(NOT BUILD_WITH_STD_FILESYSTEM) + target_compile_definitions(${TARGET_NAME} PRIVATE DISABLE_STD_FILESYSTEM) + else() + if(HAVE_FILESYSTEM_NEEDS_17) + set_property(TARGET ${TARGET_NAME} PROPERTY CXX_STANDARD 17) + set_property(TARGET ${TARGET_NAME} PROPERTY CXX_STANDARD_REQUIRED TRUE) + endif() + if(NOT HAVE_FILESYSTEM_WITHOUT_LIB) + if(HAVE_FILESYSTEM_NEEDING_LIBSTDCXXFS) + target_link_libraries(${TARGET_NAME} PRIVATE stdc++fs) + elseif(HAVE_FILESYSTEM_NEEDING_LIBCXXFS) + target_link_libraries(${TARGET_NAME} PRIVATE c++fs) + endif() + endif() + endif() +endfunction() diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/cmake/cmake_uninstall.cmake.in b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/cmake_uninstall.cmake.in new file mode 100644 index 0000000..35f459a --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/cmake_uninstall.cmake.in @@ -0,0 +1,57 @@ +# Derived from the file in the CMake source code. +# Distributed under the OSI-approved BSD 3-Clause License. +# +# CMake - Cross Platform Makefile Generator +# Copyright 2000-2020 Kitware, Inc. and Contributors +# All rights reserved. +# +# SPDX-License-Identifier: BSD-3-Clause +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# * Neither the name of Kitware, Inc. nor the names of Contributors +# may be used to endorse or promote products derived from this +# software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +if(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt") + message(FATAL_ERROR "Cannot find install manifest: @CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt") +endif(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt") + +file(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files) +string(REGEX REPLACE "\n" ";" files "${files}") +foreach(file ${files}) + message(STATUS "Uninstalling $ENV{DESTDIR}${file}") + if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") + exec_program( + "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\"" + OUTPUT_VARIABLE rm_out + RETURN_VALUE rm_retval + ) + if(NOT "${rm_retval}" STREQUAL 0) + message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}") + endif(NOT "${rm_retval}" STREQUAL 0) + else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") + message(STATUS "File $ENV{DESTDIR}${file} does not exist.") + endif(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") +endforeach(file) diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/cmake/fxc_shader.cmake b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/fxc_shader.cmake new file mode 100644 index 0000000..7bc492e --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/fxc_shader.cmake @@ -0,0 +1,37 @@ +# Copyright (c) 2019-2026 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 + +find_program(FXC_EXECUTABLE fxc) +function(fxc_shader) + set(options) + set(oneValueArgs INPUT OUTPUT TYPE VARIABLE PROFILE) + set(multiValueArgs DEFINES EXTRA_DEPENDS) + cmake_parse_arguments(_fxc "${options}" "${oneValueArgs}" + "${multiValueArgs}" ${ARGN}) + if(FXC_EXECUTABLE) + set(_fxc "${FXC_EXECUTABLE}") + else() + # Hope/assume that it will be in the path at build time + set(_fxc "fxc.exe") + endif() + set(defineArgList) + foreach(define IN LISTS _fxc_DEFINES) + list(APPEND defineArgList "/D" "${define}=1") + endforeach() + add_custom_command( + OUTPUT "${_fxc_OUTPUT}" + BYPRODUCTS "${_fxc_OUTPUT}.pdb" + COMMAND + "${_fxc}" /nologo "/Fh${_fxc_OUTPUT}" + "$<$<OR:$<CONFIG:Debug>,$<CONFIG:RelWithDebInfo>>:/Fd${_fxc_OUTPUT}.pdb>" + "/T${_fxc_PROFILE}" + "/Vn" "${_fxc_VARIABLE}" + ${defineArgList} + $<$<CONFIG:Debug>:/Od> $<$<CONFIG:Debug>:/Zss> + $<$<OR:$<CONFIG:Debug>,$<CONFIG:RelWithDebInfo>>:/Zi> "${_fxc_INPUT}" + MAIN_DEPENDENCY "${_fxc_INPUT}" + DEPENDS "${_fxc_INPUT}" ${_fxc_EXTRA_DEPENDS} + USES_TERMINAL) + +endfunction() diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/cmake/glsl_shader.cmake b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/glsl_shader.cmake new file mode 100644 index 0000000..e9745a2 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/glsl_shader.cmake @@ -0,0 +1,62 @@ +# Copyright (c) 2019-2026 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 + +function(glsl_spv_shader) + set(options) + set(oneValueArgs INPUT OUTPUT STAGE VARIABLE TARGET_ENV) + set(multiValueArgs DEFINES EXTRA_DEPENDS) + cmake_parse_arguments(_glsl_spv "${options}" "${oneValueArgs}" + "${multiValueArgs}" ${ARGN}) + + set(defineArgList) + foreach(define IN LISTS _glsl_spv_DEFINES) + list(APPEND defineArgList "-D${define}") + endforeach() + + if(GLSL_COMPILER) + add_custom_command( + OUTPUT "${_glsl_spv_OUTPUT}" + COMMAND + "${GLSL_COMPILER}" # + "-mfmt=c" # + "-fshader-stage=${_glsl_spv_STAGE}" # + ${defineArgList} # + "${_glsl_spv_INPUT}" # + -o "${_glsl_spv_OUTPUT}" # + "--target-env=${_glsl_spv_TARGET_ENV}" # + $<IF:$<OR:$<CONFIG:Debug>,$<CONFIG:RelWithDebInfo>>,-g,> # + $<IF:$<CONFIG:Debug>,-O0,-O> # + MAIN_DEPENDENCY "${_glsl_spv_INPUT}" + DEPENDS "${_glsl_spv_INPUT}" ${_glsl_spv_EXTRA_DEPENDS} + USES_TERMINAL) + + elseif(GLSLANG_VALIDATOR) + # Run glslangValidator if we can find it + add_custom_command( + OUTPUT "${_glsl_spv_OUTPUT}" + COMMAND + "${GLSLANG_VALIDATOR}" # + -S "${_glsl_spv_STAGE}" # + ${defineArgList} # + #--nan-clamp # + -x # output as hex + -o "${_glsl_spv_OUTPUT}" # + $<$<CONFIG:Debug,RelWithDebInfo>:-gVS> # + $<$<CONFIG:Debug>:-Od> # + $<$<CONFIG:Release>:-g0> # + "--target-env" "${_glsl_spv_TARGET_ENV}" # + "${_glsl_spv_INPUT}" # + MAIN_DEPENDENCY "${_glsl_spv_INPUT}" + DEPENDS "${_glsl_spv_INPUT}" ${_glsl_spv_EXTRA_DEPENDS} + USES_TERMINAL) + + else() + # Use the precompiled .spv files + get_filename_component(glsl_src_dir "${_glsl_spv_INPUT}" DIRECTORY) + + get_filename_component(glsl_name_we "${_glsl_spv_INPUT}" NAME_WE) + set(precompiled_file ${glsl_src_dir}/${glsl_name_we}.spv) + configure_file("${precompiled_file}" "${_glsl_spv_OUTPUT}" COPYONLY) + endif() +endfunction() diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/cmake/make_includable.cmake b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/make_includable.cmake new file mode 100644 index 0000000..a677a92 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/make_includable.cmake @@ -0,0 +1,34 @@ +# Copyright (c) 2019-2026 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 + +# inspired by: https://stackoverflow.com/a/47801116 +function(make_includable input_file output_file) + cmake_parse_arguments( + PARSE_ARGV 2 MAKE_INCLUDABLE "" "" "REPLACE") + + file(READ "${input_file}" content) + + # regex replace + list(LENGTH MAKE_INCLUDABLE_REPLACE length) + while(length GREATER_EQUAL 2) + list(GET MAKE_INCLUDABLE_REPLACE 0 find) + list(GET MAKE_INCLUDABLE_REPLACE 1 replace) + list(REMOVE_AT MAKE_INCLUDABLE_REPLACE 0 1) + string(REGEX REPLACE "${find}" "${replace}" content_after_replace "${content}") + if("${content_after_replace}" STREQUAL "${content}") + # Error on no change for now. If no-op replaces are required, another replace argument can be added. + message( + FATAL_ERROR + "replacement rule \"${find}\" -> \"${replace}\" had no effect on ${input_file}." + ) + endif() + set(content "${content_after_replace}") + list(LENGTH MAKE_INCLUDABLE_REPLACE length) + endwhile() + + file(WRITE "${output_file}" "R\"raw_text(${content})raw_text\"") + # using https://stackoverflow.com/a/65945763 + # see https://stackoverflow.com/a/56828572 for a different approach + set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${input_file}") +endfunction() diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/cmake/metaconfig.cmake.in b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/metaconfig.cmake.in new file mode 100644 index 0000000..fba9b38 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/metaconfig.cmake.in @@ -0,0 +1,25 @@ +# Copyright (c) 2017-2026 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 +# +# @WARNING@ + +unset(_UWP_SUFFIX) +if(CMAKE_SYSTEM_NAME STREQUAL "WindowsStore") + set(_UWP_SUFFIX _uwp) +endif() +if(CMAKE_GENERATOR_PLATFORM_UPPER MATCHES "ARM.*") + if(CMAKE_SIZEOF_VOID_P EQUAL 8) + set(_PLATFORM ARM64) + else() + set(_PLATFORM ARM) + endif() +else() + if(CMAKE_SIZEOF_VOID_P EQUAL 8) + set(_PLATFORM x64) + else() + set(_PLATFORM Win32) + endif() +endif() + +include("${CMAKE_CURRENT_LIST_DIR}/${_PLATFORM}${_UWP_SUFFIX}/lib/@TARGET_SUBDIR@/@FN@.cmake") diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/cmake/metaconfig_android.cmake.in b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/metaconfig_android.cmake.in new file mode 100644 index 0000000..2f43662 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/metaconfig_android.cmake.in @@ -0,0 +1,7 @@ +# Copyright (c) 2017-2026 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 +# +# @WARNING@ + +include("${CMAKE_CURRENT_LIST_DIR}/prefab/modules/openxr_loader/libs/android.${ANDROID_ABI}/@TARGET_SUBDIR@/@FN@.cmake") diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/cmake/presentation.cmake b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/presentation.cmake new file mode 100644 index 0000000..33bad79 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/cmake/presentation.cmake @@ -0,0 +1,159 @@ +# Copyright (c) 2017-2026 The Khronos Group Inc. +# +# SPDX-License-Identifier: Apache-2.0 + +set(PRESENTATION_BACKENDS xlib xcb wayland) +set(PRESENTATION_BACKEND + xlib + CACHE STRING "Presentation backend chosen at configure time" +) +set_property(CACHE PRESENTATION_BACKEND PROPERTY STRINGS ${PRESENTATION_BACKENDS}) + +list(FIND PRESENTATION_BACKENDS ${PRESENTATION_BACKEND} index) +if(index EQUAL -1) + message(FATAL_ERROR "Presentation backend must be one of ${PRESENTATION_BACKENDS}") +endif() + +message(STATUS "Presentation backend selected for hello_xr, loader_test, conformance: ${PRESENTATION_BACKEND}") + +find_package(X11) + +find_package(PkgConfig) + +if(PKG_CONFIG_FOUND) + pkg_search_module(XCB xcb) + pkg_search_module(XCB_GLX xcb-glx) + + pkg_search_module(WAYLAND_CLIENT wayland-client) +endif() + +include(CMakeDependentOption) +cmake_dependent_option( + BUILD_WITH_XLIB_HEADERS "Build with support for X11/Xlib-related features." ON "X11_FOUND" OFF +) +cmake_dependent_option( + BUILD_WITH_XCB_HEADERS "Build with support for XCB-related features." ON "X11_FOUND AND XCB_FOUND AND XCB_GLX_FOUND" OFF +) +cmake_dependent_option( + BUILD_WITH_WAYLAND_HEADERS "Build with support for Wayland-related features." ON "WAYLAND_CLIENT_FOUND" + OFF +) + +message(STATUS "BUILD_WITH_XLIB_HEADERS: ${BUILD_WITH_XLIB_HEADERS}") +message(STATUS "BUILD_WITH_XCB_HEADERS: ${BUILD_WITH_XCB_HEADERS}") +message(STATUS "BUILD_WITH_WAYLAND_HEADERS: ${BUILD_WITH_WAYLAND_HEADERS}") + +if(PRESENTATION_BACKEND MATCHES "xlib") + if(NOT BUILD_WITH_XLIB_HEADERS) + message( + FATAL_ERROR + "xlib backend selected, but BUILD_WITH_XLIB_HEADERS either disabled or unavailable due to missing dependencies." + ) + endif() + if(BUILD_TESTS AND (NOT X11_Xxf86vm_LIB OR NOT X11_Xrandr_LIB)) + message(FATAL_ERROR "OpenXR tests using xlib backend requires Xxf86vm and Xrandr") + endif() + + if(TARGET openxr-gfxwrapper) + target_compile_definitions(openxr-gfxwrapper PUBLIC OS_LINUX_XLIB) + target_link_libraries(openxr-gfxwrapper PRIVATE ${X11_X11_LIB} ${X11_Xxf86vm_LIB} ${X11_Xrandr_LIB}) + + # OpenGL::OpenGL already linked, we just need to add GLX. + if(TARGET OpenGL::GLX) + target_link_libraries(openxr-gfxwrapper PUBLIC OpenGL::GLX) + else() + if(${OPENGL_glx_LIBRARY}) + target_link_libraries(openxr-gfxwrapper PUBLIC ${OPENGL_glx_LIBRARY}) + endif() + target_link_libraries(openxr-gfxwrapper PUBLIC ${OPENGL_LIBRARIES}) + endif() + endif() +elseif(PRESENTATION_BACKEND MATCHES "xcb") + if(NOT BUILD_WITH_XCB_HEADERS) + message( + FATAL_ERROR + "xcb backend selected, but BUILD_WITH_XCB_HEADERS either disabled or unavailable due to missing dependencies." + ) + endif() + pkg_search_module(XCB_RANDR REQUIRED xcb-randr) + pkg_search_module(XCB_KEYSYMS REQUIRED xcb-keysyms) + pkg_search_module(XCB_GLX REQUIRED xcb-glx) + pkg_search_module(XCB_DRI2 REQUIRED xcb-dri2) + pkg_search_module(XCB_ICCCM REQUIRED xcb-icccm) + + if(TARGET openxr-gfxwrapper) + # XCB + XCB GLX is limited to OpenGL 2.1 + # target_compile_definitions(openxr-gfxwrapper PUBLIC OS_LINUX_XCB ) + # XCB + Xlib GLX 1.3 + target_compile_definitions(openxr-gfxwrapper PUBLIC OS_LINUX_XCB_GLX) + + target_link_libraries(openxr-gfxwrapper PRIVATE ${X11_X11_LIB} ${XCB_KEYSYMS_LIBRARIES} ${XCB_RANDR_LIBRARIES}) + + endif() +elseif(PRESENTATION_BACKEND MATCHES "wayland") + if(NOT BUILD_WITH_WAYLAND_HEADERS) + message( + FATAL_ERROR + "wayland backend selected, but BUILD_WITH_WAYLAND_HEADERS either disabled or unavailable due to missing dependencies." + ) + endif() + + pkg_search_module(WAYLAND_EGL REQUIRED wayland-egl) + pkg_search_module(WAYLAND_SCANNER REQUIRED wayland-scanner) + pkg_search_module(WAYLAND_PROTOCOLS REQUIRED wayland-protocols>=1.7) + pkg_search_module(EGL REQUIRED egl) + + if(TARGET openxr-gfxwrapper) + # generate wayland protocols + set(WAYLAND_PROTOCOLS_DIR ${PROJECT_BINARY_DIR}/wayland-protocols/) + file(MAKE_DIRECTORY ${WAYLAND_PROTOCOLS_DIR}) + + pkg_get_variable(WAYLAND_PROTOCOLS_DATADIR wayland-protocols pkgdatadir) + pkg_get_variable(WAYLAND_SCANNER wayland-scanner wayland_scanner) + + set(PROTOCOL xdg-shell-unstable-v6) + set(PROTOCOL_XML ${WAYLAND_PROTOCOLS_DATADIR}/unstable/xdg-shell/${PROTOCOL}.xml) + + if(NOT EXISTS ${PROTOCOL_XML}) + message(FATAL_ERROR "xdg-shell-unstable-v6.xml not found in " ${WAYLAND_PROTOCOLS_DATADIR} + "\nYour wayland-protocols package does not " "contain xdg-shell-unstable-v6." + ) + endif() + add_custom_command( + OUTPUT ${WAYLAND_PROTOCOLS_DIR}/${PROTOCOL}.c + COMMAND ${WAYLAND_SCANNER} code ${PROTOCOL_XML} ${WAYLAND_PROTOCOLS_DIR}/${PROTOCOL}.c + VERBATIM + ) + add_custom_command( + OUTPUT ${WAYLAND_PROTOCOLS_DIR}/${PROTOCOL}.h + COMMAND ${WAYLAND_SCANNER} client-header ${PROTOCOL_XML} ${WAYLAND_PROTOCOLS_DIR}/${PROTOCOL}.h + VERBATIM + ) + + target_sources(openxr-gfxwrapper + PRIVATE + ${WAYLAND_PROTOCOLS_DIR}/${PROTOCOL}.c + ${WAYLAND_PROTOCOLS_DIR}/${PROTOCOL}.h + ) + + target_include_directories(openxr-gfxwrapper PUBLIC ${WAYLAND_PROTOCOLS_DIR} ${WAYLAND_CLIENT_INCLUDE_DIRS}) + target_link_libraries( + openxr-gfxwrapper PRIVATE ${EGL_LIBRARIES} ${WAYLAND_CLIENT_LIBRARIES} ${WAYLAND_EGL_LIBRARIES} + ) + target_compile_definitions(openxr-gfxwrapper PUBLIC OS_LINUX_WAYLAND) + target_link_libraries(openxr-gfxwrapper PRIVATE ${EGL_LIBRARIES} ${WAYLAND_CLIENT_LIBRARIES}) + endif() +endif() + + +if(TARGET openxr-gfxwrapper AND NOT (PRESENTATION_BACKEND MATCHES "wayland")) + if(TARGET OpenGL::GLX) + # OpenGL::OpenGL already linked, we just need to add GLX. + target_link_libraries(openxr-gfxwrapper PUBLIC OpenGL::GLX) + else() + if(${OPENGL_glx_LIBRARY}) + target_link_libraries(openxr-gfxwrapper PUBLIC ${OPENGL_glx_LIBRARY}) + endif() + target_link_libraries(openxr-gfxwrapper PUBLIC ${OPENGL_LIBRARIES}) + endif() +endif() diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/common/android_logging.h b/shadps4-arm64-main/externals/openxr-sdk/src/common/android_logging.h new file mode 100644 index 0000000..242fbc5 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/common/android_logging.h @@ -0,0 +1,22 @@ +// Copyright (c) 2018-2026 The Khronos Group Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// +// Utility macros for Android logging. + +#pragma once + +#ifdef XR_USE_PLATFORM_ANDROID +#include <android/log.h> + +#if !defined(LOG_TAG) +#error "LOG_TAG must be defined before including android_logging.h" +#endif + +#define ALOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, __VA_ARGS__) +#define ALOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__) +#define ALOGW(...) __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__) +#define ALOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__) +#define ALOGF(...) __android_log_print(ANDROID_LOG_FATAL, LOG_TAG, __VA_ARGS__) + +#endif // XR_USE_PLATFORM_ANDROID diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/common/extra_algorithms.h b/shadps4-arm64-main/externals/openxr-sdk/src/common/extra_algorithms.h new file mode 100644 index 0000000..3dc9856 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/common/extra_algorithms.h @@ -0,0 +1,47 @@ +// Copyright (c) 2017-2026 The Khronos Group Inc. +// Copyright (c) 2017-2019 Valve Corporation +// Copyright (c) 2017-2019 LunarG, Inc. +// Copyright (c) 2019 Collabora, Ltd. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// +// Initial Author: Rylie Pavlik <rylie.pavlik@collabora.com> +// + +/*! + * @file + * + * Additional functions along the lines of the standard library algorithms. + */ + +#pragma once + +#include <algorithm> +#include <vector> + +/// Like std::remove_if, except it works on associative containers and it actually removes this. +/// +/// The iterator stuff in here is subtle - .erase() invalidates only that iterator, but it returns a non-invalidated iterator to the +/// next valid element which we can use instead of incrementing. +template <typename T, typename Pred> +static inline void map_erase_if(T &container, Pred &&predicate) { + for (auto it = container.begin(); it != container.end();) { + if (predicate(*it)) { + it = container.erase(it); + } else { + ++it; + } + } +} + +/*! + * Moves all elements matching the predicate to the end of the vector then erases them. + * + * Combines the two parts of the erase-remove idiom to simplify things and avoid accidentally using the wrong erase overload. + */ +template <typename T, typename Alloc, typename Pred> +static inline void vector_remove_if_and_erase(std::vector<T, Alloc> &vec, Pred &&predicate) { + auto b = vec.begin(); + auto e = vec.end(); + vec.erase(std::remove_if(b, e, std::forward<Pred>(predicate)), e); +} diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/common/filesystem_utils.cpp b/shadps4-arm64-main/externals/openxr-sdk/src/common/filesystem_utils.cpp new file mode 100644 index 0000000..b5b0162 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/common/filesystem_utils.cpp @@ -0,0 +1,322 @@ +// Copyright (c) 2017-2026 The Khronos Group Inc. +// Copyright (c) 2017 Valve Corporation +// Copyright (c) 2017 LunarG, Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// +// Initial Authors: Mark Young <marky@lunarg.com> +// Nat Brown <natb@valvesoftware.com> +// + +#include "filesystem_utils.hpp" + +#include "platform_utils.hpp" + +#include <cstring> +#include <string> + +#if defined DISABLE_STD_FILESYSTEM +#define USE_EXPERIMENTAL_FS 0 +#define USE_FINAL_FS 0 + +#else +#include "stdfs_conditions.h" +#endif + +#if USE_FINAL_FS == 1 +#include <filesystem> +#define FS_PREFIX std::filesystem +#elif USE_EXPERIMENTAL_FS == 1 +#include <experimental/filesystem> +#define FS_PREFIX std::experimental::filesystem +#elif defined(XR_USE_PLATFORM_WIN32) +// Windows fallback includes +#include <stdint.h> +#include <direct.h> +#else +// Linux/Apple fallback includes +#include <sys/stat.h> +#include <unistd.h> +#include <limits.h> +#include <stdlib.h> +#include <dirent.h> +#endif + +#if defined(XR_USE_PLATFORM_WIN32) +#define PATH_SEPARATOR ';' +#define DIRECTORY_SYMBOL '\\' +#define ALTERNATE_DIRECTORY_SYMBOL '/' +#else +#define PATH_SEPARATOR ':' +#define DIRECTORY_SYMBOL '/' +#endif + +#if (USE_FINAL_FS == 1) || (USE_EXPERIMENTAL_FS == 1) +// We can use one of the C++ filesystem packages + +bool FileSysUtilsIsRegularFile(const std::string& path) { return FS_PREFIX::is_regular_file(path); } + +bool FileSysUtilsIsDirectory(const std::string& path) { return FS_PREFIX::is_directory(path); } + +bool FileSysUtilsPathExists(const std::string& path) { return FS_PREFIX::exists(path); } + +bool FileSysUtilsIsAbsolutePath(const std::string& path) { + FS_PREFIX::path file_path(path); + return file_path.is_absolute(); +} + +bool FileSysUtilsGetCurrentPath(std::string& path) { + FS_PREFIX::path cur_path = FS_PREFIX::current_path(); + path = cur_path.string(); + return true; +} + +bool FileSysUtilsGetParentPath(const std::string& file_path, std::string& parent_path) { + FS_PREFIX::path path_var(file_path); + parent_path = path_var.parent_path().string(); + return true; +} + +bool FileSysUtilsGetAbsolutePath(const std::string& path, std::string& absolute) { + absolute = FS_PREFIX::absolute(path).string(); + return true; +} + +bool FileSysUtilsGetCanonicalPath(const std::string& path, std::string& canonical) { +#if defined(XR_USE_PLATFORM_WIN32) + // std::filesystem::canonical fails on UWP and must be avoided. Further, PathCchCanonicalize is not available on Windows 7 and + // PathCanonicalizeW is not available on UWP. However, symbolic links are not important on Windows since the loader uses the + // registry for indirection instead, and so this function can be a no-op on Windows. + canonical = path; +#else + canonical = FS_PREFIX::canonical(path).string(); +#endif + return true; +} + +bool FileSysUtilsCombinePaths(const std::string& parent, const std::string& child, std::string& combined) { + FS_PREFIX::path parent_path(parent); + FS_PREFIX::path child_path(child); + FS_PREFIX::path full_path = parent_path / child_path; + combined = full_path.string(); + return true; +} + +bool FileSysUtilsParsePathList(std::string& path_list, std::vector<std::string>& paths) { + std::string::size_type start = 0; + std::string::size_type location = path_list.find(PATH_SEPARATOR); + while (location != std::string::npos) { + paths.push_back(path_list.substr(start, location)); + start = location + 1; + location = path_list.find(PATH_SEPARATOR, start); + } + paths.push_back(path_list.substr(start, location)); + return true; +} + +bool FileSysUtilsFindFilesInPath(const std::string& path, std::vector<std::string>& files) { + for (auto& dir_iter : FS_PREFIX::directory_iterator(path)) { + files.push_back(dir_iter.path().filename().string()); + } + return true; +} + +#elif defined(XR_OS_WINDOWS) + +// For pre C++17 compiler that doesn't support experimental filesystem + +bool FileSysUtilsIsRegularFile(const std::string& path) { + const DWORD attr = GetFileAttributesW(utf8_to_wide(path).c_str()); + return attr != INVALID_FILE_ATTRIBUTES && !(attr & FILE_ATTRIBUTE_DIRECTORY); +} + +bool FileSysUtilsIsDirectory(const std::string& path) { + const DWORD attr = GetFileAttributesW(utf8_to_wide(path).c_str()); + return attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_DIRECTORY); +} + +bool FileSysUtilsPathExists(const std::string& path) { + return (GetFileAttributesW(utf8_to_wide(path).c_str()) != INVALID_FILE_ATTRIBUTES); +} + +bool FileSysUtilsIsAbsolutePath(const std::string& path) { + bool pathStartsWithDir = (path.size() >= 1) && ((path[0] == DIRECTORY_SYMBOL) || (path[0] == ALTERNATE_DIRECTORY_SYMBOL)); + + bool pathStartsWithDrive = + (path.size() >= 3) && (path[1] == ':' && (path[2] == DIRECTORY_SYMBOL || path[2] == ALTERNATE_DIRECTORY_SYMBOL)); + + return pathStartsWithDir || pathStartsWithDrive; +} + +bool FileSysUtilsGetCurrentPath(std::string& path) { + wchar_t tmp_path[MAX_PATH]; + if (nullptr != _wgetcwd(tmp_path, MAX_PATH - 1)) { + path = wide_to_utf8(tmp_path); + return true; + } + return false; +} + +bool FileSysUtilsGetParentPath(const std::string& file_path, std::string& parent_path) { + std::string full_path; + if (FileSysUtilsGetAbsolutePath(file_path, full_path)) { + std::string::size_type lastSeparator = full_path.find_last_of(DIRECTORY_SYMBOL); + parent_path = (lastSeparator == 0) ? full_path : full_path.substr(0, lastSeparator); + return true; + } + return false; +} + +bool FileSysUtilsGetAbsolutePath(const std::string& path, std::string& absolute) { + wchar_t tmp_path[MAX_PATH]; + if (0 != GetFullPathNameW(utf8_to_wide(path).c_str(), MAX_PATH, tmp_path, NULL)) { + absolute = wide_to_utf8(tmp_path); + return true; + } + return false; +} + +bool FileSysUtilsGetCanonicalPath(const std::string& path, std::string& absolute) { + // PathCchCanonicalize is not available on Windows 7 and PathCanonicalizeW is not available on UWP. However, symbolic links are + // not important on Windows since the loader uses the registry for indirection instead, and so this function can be a no-op on + // Windows. + absolute = path; + return true; +} + +bool FileSysUtilsCombinePaths(const std::string& parent, const std::string& child, std::string& combined) { + std::string::size_type parent_len = parent.length(); + if (0 == parent_len || "." == parent || ".\\" == parent || "./" == parent) { + combined = child; + return true; + } + char last_char = parent[parent_len - 1]; + if ((last_char == DIRECTORY_SYMBOL) || (last_char == ALTERNATE_DIRECTORY_SYMBOL)) { + parent_len--; + } + combined = parent.substr(0, parent_len) + DIRECTORY_SYMBOL + child; + return true; +} + +bool FileSysUtilsParsePathList(std::string& path_list, std::vector<std::string>& paths) { + std::string::size_type start = 0; + std::string::size_type location = path_list.find(PATH_SEPARATOR); + while (location != std::string::npos) { + paths.push_back(path_list.substr(start, location)); + start = location + 1; + location = path_list.find(PATH_SEPARATOR, start); + } + paths.push_back(path_list.substr(start, location)); + return true; +} + +bool FileSysUtilsFindFilesInPath(const std::string& path, std::vector<std::string>& files) { + std::string searchPath; + FileSysUtilsCombinePaths(path, "*", searchPath); + + WIN32_FIND_DATAW file_data; + HANDLE file_handle = FindFirstFileW(utf8_to_wide(searchPath).c_str(), &file_data); + if (file_handle != INVALID_HANDLE_VALUE) { + do { + if (!(file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) { + files.push_back(wide_to_utf8(file_data.cFileName)); + } + } while (FindNextFileW(file_handle, &file_data)); + return true; + } + return false; +} + +#else // XR_OS_LINUX/XR_OS_APPLE fallback + +// simple POSIX-compatible implementation of the <filesystem> pieces used by OpenXR + +bool FileSysUtilsIsRegularFile(const std::string& path) { + struct stat path_stat; + stat(path.c_str(), &path_stat); + return S_ISREG(path_stat.st_mode); +} + +bool FileSysUtilsIsDirectory(const std::string& path) { + struct stat path_stat; + stat(path.c_str(), &path_stat); + return S_ISDIR(path_stat.st_mode); +} + +bool FileSysUtilsPathExists(const std::string& path) { return (access(path.c_str(), F_OK) != -1); } + +bool FileSysUtilsIsAbsolutePath(const std::string& path) { return (path[0] == DIRECTORY_SYMBOL); } + +bool FileSysUtilsGetCurrentPath(std::string& path) { + char tmp_path[PATH_MAX]; + if (nullptr != getcwd(tmp_path, PATH_MAX - 1)) { + path = tmp_path; + return true; + } + return false; +} + +bool FileSysUtilsGetParentPath(const std::string& file_path, std::string& parent_path) { + std::string full_path; + if (FileSysUtilsGetAbsolutePath(file_path, full_path)) { + std::string::size_type lastSeparator = full_path.find_last_of(DIRECTORY_SYMBOL); + parent_path = (lastSeparator == 0) ? full_path : full_path.substr(0, lastSeparator); + return true; + } + return false; +} + +bool FileSysUtilsGetAbsolutePath(const std::string& path, std::string& absolute) { + // canonical path is absolute + return FileSysUtilsGetCanonicalPath(path, absolute); +} + +bool FileSysUtilsGetCanonicalPath(const std::string& path, std::string& canonical) { + char buf[PATH_MAX]; + if (nullptr != realpath(path.c_str(), buf)) { + canonical = buf; + return true; + } + return false; +} + +bool FileSysUtilsCombinePaths(const std::string& parent, const std::string& child, std::string& combined) { + std::string::size_type parent_len = parent.length(); + if (0 == parent_len || "." == parent || "./" == parent) { + combined = child; + return true; + } + char last_char = parent[parent_len - 1]; + if (last_char == DIRECTORY_SYMBOL) { + parent_len--; + } + combined = parent.substr(0, parent_len) + DIRECTORY_SYMBOL + child; + return true; +} + +bool FileSysUtilsParsePathList(std::string& path_list, std::vector<std::string>& paths) { + std::string::size_type start = 0; + std::string::size_type location = path_list.find(PATH_SEPARATOR); + while (location != std::string::npos) { + paths.push_back(path_list.substr(start, location)); + start = location + 1; + location = path_list.find(PATH_SEPARATOR, start); + } + paths.push_back(path_list.substr(start, location)); + return true; +} + +bool FileSysUtilsFindFilesInPath(const std::string& path, std::vector<std::string>& files) { + DIR* dir = opendir(path.c_str()); + if (dir == nullptr) { + return false; + } + struct dirent* entry; + while ((entry = readdir(dir)) != nullptr) { + files.emplace_back(entry->d_name); + } + closedir(dir); + return true; +} + +#endif diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/common/filesystem_utils.hpp b/shadps4-arm64-main/externals/openxr-sdk/src/common/filesystem_utils.hpp new file mode 100644 index 0000000..05d2953 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/common/filesystem_utils.hpp @@ -0,0 +1,46 @@ +// Copyright (c) 2017-2026 The Khronos Group Inc. +// Copyright (c) 2017 Valve Corporation +// Copyright (c) 2017 LunarG, Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// +// Initial Author: Mark Young <marky@lunarg.com> +// + +#pragma once + +#include <string> +#include <vector> + +// Determine if the path indicates a regular file (not a directory or symbolic link) +bool FileSysUtilsIsRegularFile(const std::string& path); + +// Determine if the path indicates a directory +bool FileSysUtilsIsDirectory(const std::string& path); + +// Determine if the provided path exists on the filesystem +bool FileSysUtilsPathExists(const std::string& path); + +// Get the current directory +bool FileSysUtilsGetCurrentPath(std::string& path); + +// Get the parent path of a file +bool FileSysUtilsGetParentPath(const std::string& file_path, std::string& parent_path); + +// Determine if the provided path is an absolute path +bool FileSysUtilsIsAbsolutePath(const std::string& path); + +// Get the absolute path for a provided file +bool FileSysUtilsGetAbsolutePath(const std::string& path, std::string& absolute); + +// Get the absolute path for a provided file +bool FileSysUtilsGetCanonicalPath(const std::string& path, std::string& canonical); + +// Combine a parent and child directory +bool FileSysUtilsCombinePaths(const std::string& parent, const std::string& child, std::string& combined); + +// Parse out individual paths in a path list +bool FileSysUtilsParsePathList(std::string& path_list, std::vector<std::string>& paths); + +// Record all the filenames for files found in the provided path. +bool FileSysUtilsFindFilesInPath(const std::string& path, std::vector<std::string>& files); diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/common/hex_and_handles.h b/shadps4-arm64-main/externals/openxr-sdk/src/common/hex_and_handles.h new file mode 100644 index 0000000..6edb29c --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/common/hex_and_handles.h @@ -0,0 +1,115 @@ +// Copyright (c) 2017-2026 The Khronos Group Inc. +// Copyright (c) 2017-2019 Valve Corporation +// Copyright (c) 2017-2019 LunarG, Inc. +// Copyright (c) 2019 Collabora, Ltd. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// +// Initial Author: Rylie Pavlik <rylie.pavlik@collabora.com> +// + +/*! + * @file + * + * Some utilities, primarily for working with OpenXR handles in a generic way. + */ + +#pragma once + +#include <openxr/openxr.h> + +#include <string> +#include <stdint.h> + +inline std::string to_hex(const uint8_t* const data, size_t bytes, bool prefix = true) { + std::string out(bytes * 2 + (prefix ? 2 : 0), '?'); + if (prefix) { + out[0] = '0'; + out[1] = 'x'; + } + static const char* hex = "0123456789abcdef"; + auto ch = out.end(); + for (size_t i = 0; i < bytes; ++i) { + auto b = data[i]; + *--ch = hex[(b >> 0) & 0xf]; + *--ch = hex[(b >> 4) & 0xf]; + } + return out; +} + +template <typename T> +inline std::string to_hex(const T& data) { + return to_hex(reinterpret_cast<const uint8_t* const>(&data), sizeof(T)); +} + +template <typename T> +inline std::string to_hex(T* const data) { + return to_hex(reinterpret_cast<const uint8_t* const>(&data), sizeof(T*)); +} + +#if XR_PTR_SIZE == 8 +/// Convert a handle into a same-sized integer. +template <typename T> +static inline uint64_t MakeHandleGeneric(T handle) { + return reinterpret_cast<uint64_t>(handle); +} + +/// Treat an integer as a handle +template <typename T> +static inline T& TreatIntegerAsHandle(uint64_t& handle) { + return reinterpret_cast<T&>(handle); +} + +/// @overload +template <typename T> +static inline T const& TreatIntegerAsHandle(uint64_t const& handle) { + return reinterpret_cast<T const&>(handle); +} + +/// Does a correctly-sized integer represent a null handle? +static inline bool IsIntegerNullHandle(uint64_t handle) { return XR_NULL_HANDLE == reinterpret_cast<void*>(handle); } + +#else + +/// Convert a handle into a same-sized integer: no-op on 32-bit systems +static inline uint64_t MakeHandleGeneric(uint64_t handle) { return handle; } + +/// Treat an integer as a handle: no-op on 32-bit systems +template <typename T> +static inline T& TreatIntegerAsHandle(uint64_t& handle) { + return handle; +} + +/// @overload +template <typename T> +static inline T const& TreatIntegerAsHandle(uint64_t const& handle) { + return handle; +} + +/// Does a correctly-sized integer represent a null handle? +static inline bool IsIntegerNullHandle(uint64_t handle) { return XR_NULL_HANDLE == handle; } + +#endif + +/// Turns a uint64_t into a string formatted as hex. +/// +/// The core of the HandleToHexString implementation is in here. +inline std::string Uint64ToHexString(uint64_t val) { return to_hex(val); } + +/// Turns a uint32_t into a string formatted as hex. +inline std::string Uint32ToHexString(uint32_t val) { return to_hex(val); } + +/// Turns an OpenXR handle into a string formatted as hex. +template <typename T> +inline std::string HandleToHexString(T handle) { + return to_hex(handle); +} + +/// Turns a pointer-sized integer into a string formatted as hex. +inline std::string UintptrToHexString(uintptr_t val) { return to_hex(val); } + +/// Convert a pointer to a string formatted as hex. +template <typename T> +inline std::string PointerToHexString(T const* ptr) { + return to_hex(ptr); +} diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/common/object_info.cpp b/shadps4-arm64-main/externals/openxr-sdk/src/common/object_info.cpp new file mode 100644 index 0000000..35edb74 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/common/object_info.cpp @@ -0,0 +1,278 @@ +// Copyright (c) 2017-2026 The Khronos Group Inc. +// Copyright (c) 2017-2019 Valve Corporation +// Copyright (c) 2017-2019 LunarG, Inc. +// Copyright (c) 2019 Collabora, Ltd. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// +// Initial Authors: Mark Young <marky@lunarg.com> +// Rylie Pavlik <rylie.pavlik@collabora.com> +// Dave Houlton <daveh@lunarg.com> +// + +#include "object_info.h" + +#include "extra_algorithms.h" +#include "hex_and_handles.h" + +#include <openxr/openxr.h> + +#include <algorithm> +#include <iterator> +#include <memory> +#include <sstream> +#include <string> +#include <vector> + +#include "memory.h" + +std::string XrSdkLogObjectInfo::ToString() const { + std::ostringstream oss; + oss << Uint64ToHexString(handle); + if (!name.empty()) { + oss << " (" << name << ")"; + } + return oss.str(); +} + +void ObjectInfoCollection::AddObjectName(uint64_t object_handle, XrObjectType object_type, const std::string& object_name) { + // If name is empty, we should erase it + if (object_name.empty()) { + RemoveObject(object_handle, object_type); + return; + } + + // Otherwise, add it or update the name + XrSdkLogObjectInfo new_obj = {object_handle, object_type}; + + // If it already exists, update the name + auto lookup_info = LookUpStoredObjectInfo(new_obj); + if (lookup_info != nullptr) { + lookup_info->name = object_name; + return; + } + + // It doesn't exist, so add a new info block + new_obj.name = object_name; + object_info_.push_back(new_obj); +} + +void ObjectInfoCollection::RemoveObject(uint64_t object_handle, XrObjectType object_type) { + vector_remove_if_and_erase( + object_info_, [=](XrSdkLogObjectInfo const& info) { return info.handle == object_handle && info.type == object_type; }); +} + +XrSdkLogObjectInfo const* ObjectInfoCollection::LookUpStoredObjectInfo(XrSdkLogObjectInfo const& info) const { + auto e = object_info_.end(); + auto it = std::find_if(object_info_.begin(), e, [&](XrSdkLogObjectInfo const& stored) { return Equivalent(stored, info); }); + if (it != e) { + return &(*it); + } + return nullptr; +} + +XrSdkLogObjectInfo* ObjectInfoCollection::LookUpStoredObjectInfo(XrSdkLogObjectInfo const& info) { + auto e = object_info_.end(); + auto it = std::find_if(object_info_.begin(), e, [&](XrSdkLogObjectInfo const& stored) { return Equivalent(stored, info); }); + if (it != e) { + return &(*it); + } + return nullptr; +} + +bool ObjectInfoCollection::LookUpObjectName(XrDebugUtilsObjectNameInfoEXT& info) const { + auto info_lookup = LookUpStoredObjectInfo(info.objectHandle, info.objectType); + if (info_lookup != nullptr) { + info.objectName = info_lookup->name.c_str(); + return true; + } + return false; +} + +bool ObjectInfoCollection::LookUpObjectName(XrSdkLogObjectInfo& info) const { + auto info_lookup = LookUpStoredObjectInfo(info); + if (info_lookup != nullptr) { + info.name = info_lookup->name; + return true; + } + return false; +} + +static std::vector<XrDebugUtilsObjectNameInfoEXT> PopulateObjectNameInfo(std::vector<XrSdkLogObjectInfo> const& obj) { + std::vector<XrDebugUtilsObjectNameInfoEXT> ret; + ret.reserve(obj.size()); + std::transform(obj.begin(), obj.end(), std::back_inserter(ret), [](XrSdkLogObjectInfo const& info) { + return XrDebugUtilsObjectNameInfoEXT{XR_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT, nullptr, info.type, info.handle, + info.name.c_str()}; + }); + return ret; +} + +NamesAndLabels::NamesAndLabels(std::vector<XrSdkLogObjectInfo> obj, std::vector<XrDebugUtilsLabelEXT> lab) + : sdk_objects(std::move(obj)), objects(PopulateObjectNameInfo(sdk_objects)), labels(std::move(lab)) {} + +void NamesAndLabels::PopulateCallbackData(XrDebugUtilsMessengerCallbackDataEXT& callback_data) const { + callback_data.objects = objects.empty() ? nullptr : const_cast<XrDebugUtilsObjectNameInfoEXT*>(objects.data()); + callback_data.objectCount = static_cast<uint32_t>(objects.size()); + callback_data.sessionLabels = labels.empty() ? nullptr : const_cast<XrDebugUtilsLabelEXT*>(labels.data()); + callback_data.sessionLabelCount = static_cast<uint32_t>(labels.size()); +} + +void DebugUtilsData::LookUpSessionLabels(XrSession session, std::vector<XrDebugUtilsLabelEXT>& labels) const { + auto session_label_iterator = session_labels_.find(session); + if (session_label_iterator != session_labels_.end()) { + auto& XrSdkSessionLabels = *session_label_iterator->second; + // Copy the debug utils labels in reverse order in the the labels vector. + std::transform(XrSdkSessionLabels.rbegin(), XrSdkSessionLabels.rend(), std::back_inserter(labels), + [](XrSdkSessionLabelPtr const& label) { return label->debug_utils_label; }); + } +} + +XrSdkSessionLabel::XrSdkSessionLabel(const XrDebugUtilsLabelEXT& label_info, bool individual) + : label_name(label_info.labelName), debug_utils_label(label_info), is_individual_label(individual) { + // Update the c string pointer to the one we hold. + debug_utils_label.labelName = label_name.c_str(); + // Zero out the next pointer to avoid a dangling pointer + debug_utils_label.next = nullptr; +} + +XrSdkSessionLabelPtr XrSdkSessionLabel::make(const XrDebugUtilsLabelEXT& label_info, bool individual) { + XrSdkSessionLabelPtr ret(new XrSdkSessionLabel(label_info, individual)); + return ret; +} +void DebugUtilsData::AddObjectName(uint64_t object_handle, XrObjectType object_type, const std::string& object_name) { + object_info_.AddObjectName(object_handle, object_type, object_name); +} + +// We always want to remove the old individual label before we do anything else. +// So, do that in its own method +void DebugUtilsData::RemoveIndividualLabel(XrSdkSessionLabelList& label_vec) { + if (!label_vec.empty() && label_vec.back()->is_individual_label) { + label_vec.pop_back(); + } +} + +XrSdkSessionLabelList* DebugUtilsData::GetSessionLabelList(XrSession session) { + auto session_label_iterator = session_labels_.find(session); + if (session_label_iterator == session_labels_.end()) { + return nullptr; + } + return session_label_iterator->second.get(); +} + +XrSdkSessionLabelList& DebugUtilsData::GetOrCreateSessionLabelList(XrSession session) { + XrSdkSessionLabelList* vec_ptr = GetSessionLabelList(session); + if (vec_ptr == nullptr) { + std::unique_ptr<XrSdkSessionLabelList> vec(new XrSdkSessionLabelList); + vec_ptr = vec.get(); + session_labels_[session] = std::move(vec); + } + return *vec_ptr; +} + +void DebugUtilsData::BeginLabelRegion(XrSession session, const XrDebugUtilsLabelEXT& label_info) { + auto& vec = GetOrCreateSessionLabelList(session); + + // Individual labels do not stay around in the transition into a new label region + RemoveIndividualLabel(vec); + + // Start the new label region + vec.emplace_back(XrSdkSessionLabel::make(label_info, false)); +} + +void DebugUtilsData::EndLabelRegion(XrSession session) { + XrSdkSessionLabelList* vec_ptr = GetSessionLabelList(session); + if (vec_ptr == nullptr) { + return; + } + + // Individual labels do not stay around in the transition out of label region + RemoveIndividualLabel(*vec_ptr); + + // Remove the last label region + if (!vec_ptr->empty()) { + vec_ptr->pop_back(); + } +} + +void DebugUtilsData::InsertLabel(XrSession session, const XrDebugUtilsLabelEXT& label_info) { + auto& vec = GetOrCreateSessionLabelList(session); + + // Remove any individual layer that might already be there + RemoveIndividualLabel(vec); + + // Insert a new individual label + vec.emplace_back(XrSdkSessionLabel::make(label_info, true)); +} + +void DebugUtilsData::DeleteObject(uint64_t object_handle, XrObjectType object_type) { + object_info_.RemoveObject(object_handle, object_type); + + if (object_type == XR_OBJECT_TYPE_SESSION) { + auto session = TreatIntegerAsHandle<XrSession>(object_handle); + XrSdkSessionLabelList* vec_ptr = GetSessionLabelList(session); + if (vec_ptr != nullptr) { + session_labels_.erase(session); + } + } +} + +void DebugUtilsData::DeleteSessionLabels(XrSession session) { session_labels_.erase(session); } + +NamesAndLabels DebugUtilsData::PopulateNamesAndLabels(std::vector<XrSdkLogObjectInfo> objects) const { + std::vector<XrDebugUtilsLabelEXT> labels; + for (auto& obj : objects) { + // Check for any names that have been associated with the objects and set them up here + object_info_.LookUpObjectName(obj); + // If this is a session, see if there are any labels associated with it for us to add + // to the callback content. + if (XR_OBJECT_TYPE_SESSION == obj.type) { + LookUpSessionLabels(obj.GetTypedHandle<XrSession>(), labels); + } + } + + return {objects, labels}; +} + +void DebugUtilsData::WrapCallbackData(AugmentedCallbackData* aug_data, + const XrDebugUtilsMessengerCallbackDataEXT* callback_data) const { + // If there's nothing to add, just return the original data as the augmented copy + aug_data->exported_data = callback_data; + if (object_info_.Empty() || callback_data->objectCount == 0) { + return; + } + + // Inspect each of the callback objects + bool name_found = false; + for (uint32_t obj = 0; obj < callback_data->objectCount; ++obj) { + auto& current_obj = callback_data->objects[obj]; + name_found |= (nullptr != object_info_.LookUpStoredObjectInfo(current_obj.objectHandle, current_obj.objectType)); + + // If this is a session, record any labels associated with it + if (XR_OBJECT_TYPE_SESSION == current_obj.objectType) { + XrSession session = TreatIntegerAsHandle<XrSession>(current_obj.objectHandle); + LookUpSessionLabels(session, aug_data->labels); + } + } + + // If we found nothing to add, return the original data + if (!name_found && aug_data->labels.empty()) { + return; + } + + // Found additional data - modify an internal copy and return that as the exported data + memcpy(&aug_data->modified_data, callback_data, sizeof(XrDebugUtilsMessengerCallbackDataEXT)); + aug_data->new_objects.assign(callback_data->objects, callback_data->objects + callback_data->objectCount); + + // Record (overwrite) the names of all incoming objects provided in our internal list + for (auto& obj : aug_data->new_objects) { + object_info_.LookUpObjectName(obj); + } + + // Update local copy & point export to it + aug_data->modified_data.objects = aug_data->new_objects.data(); + aug_data->modified_data.sessionLabelCount = static_cast<uint32_t>(aug_data->labels.size()); + aug_data->modified_data.sessionLabels = aug_data->labels.empty() ? nullptr : aug_data->labels.data(); + aug_data->exported_data = &aug_data->modified_data; + return; +} diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/common/object_info.h b/shadps4-arm64-main/externals/openxr-sdk/src/common/object_info.h new file mode 100644 index 0000000..abcba46 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/common/object_info.h @@ -0,0 +1,229 @@ +// Copyright (c) 2017-2026 The Khronos Group Inc. +// Copyright (c) 2017-2019 Valve Corporation +// Copyright (c) 2017-2019 LunarG, Inc. +// Copyright (c) 2019 Collabora, Ltd. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// +// Initial Authors: Mark Young <marky@lunarg.com>, Rylie Pavlik <rylie.pavlik@collabora.com +// +/*! + * @file + * + * The core of an XR_EXT_debug_utils implementation, used/shared by the loader and several SDK layers. + */ + +#pragma once + +#include "hex_and_handles.h" + +#include <openxr/openxr.h> + +#include <memory> +#include <string> +#include <unordered_map> +#include <vector> + +struct XrSdkGenericObject { + //! Type-erased handle value + uint64_t handle; + + //! Kind of object this handle refers to + XrObjectType type; + /// Un-erase the type of the handle and get it properly typed again. + /// + /// Note: Does not check the type before doing it! + template <typename HandleType> + HandleType& GetTypedHandle() { + return TreatIntegerAsHandle<HandleType&>(handle); + } + + //! @overload + template <typename HandleType> + HandleType const& GetTypedHandle() const { + return TreatIntegerAsHandle<HandleType&>(handle); + } + + //! Create from a typed handle and object type + template <typename T> + XrSdkGenericObject(T h, XrObjectType t) : handle(MakeHandleGeneric(h)), type(t) {} + + //! Create from an untyped handle value (integer) and object type + XrSdkGenericObject(uint64_t h, XrObjectType t) : handle(h), type(t) {} +}; + +struct XrSdkLogObjectInfo { + //! Type-erased handle value + uint64_t handle; + + //! Kind of object this handle refers to + XrObjectType type; + + //! To be assigned by the application - not part of this object's identity + std::string name; + + /// Un-erase the type of the handle and get it properly typed again. + /// + /// Note: Does not check the type before doing it! + template <typename HandleType> + HandleType& GetTypedHandle() { + return TreatIntegerAsHandle<HandleType&>(handle); + } + + //! @overload + template <typename HandleType> + HandleType const& GetTypedHandle() const { + return TreatIntegerAsHandle<HandleType&>(handle); + } + + XrSdkLogObjectInfo() = default; + + //! Create from a typed handle and object type + template <typename T> + XrSdkLogObjectInfo(T h, XrObjectType t) : handle(MakeHandleGeneric(h)), type(t) {} + + //! Create from an untyped handle value (integer) and object type + XrSdkLogObjectInfo(uint64_t h, XrObjectType t) : handle(h), type(t) {} + //! Create from an untyped handle value (integer), object type, and name + XrSdkLogObjectInfo(uint64_t h, XrObjectType t, const char* n) : handle(h), type(t), name(n == nullptr ? "" : n) {} + + std::string ToString() const; +}; + +//! True if the two object infos have the same handle value and handle type +static inline bool Equivalent(XrSdkLogObjectInfo const& a, XrSdkLogObjectInfo const& b) { + return a.handle == b.handle && a.type == b.type; +} + +//! @overload +static inline bool Equivalent(XrDebugUtilsObjectNameInfoEXT const& a, XrSdkLogObjectInfo const& b) { + return a.objectHandle == b.handle && a.objectType == b.type; +} + +//! @overload +static inline bool Equivalent(XrSdkLogObjectInfo const& a, XrDebugUtilsObjectNameInfoEXT const& b) { return Equivalent(b, a); } + +/// Object info registered with calls to xrSetDebugUtilsObjectNameEXT +class ObjectInfoCollection { + public: + void AddObjectName(uint64_t object_handle, XrObjectType object_type, const std::string& object_name); + + void RemoveObject(uint64_t object_handle, XrObjectType object_type); + + //! Find the stored object info, if any, matching handle and type. + //! Return nullptr if not found. + XrSdkLogObjectInfo const* LookUpStoredObjectInfo(XrSdkLogObjectInfo const& info) const; + + //! Find the stored object info, if any, matching handle and type. + //! Return nullptr if not found. + XrSdkLogObjectInfo* LookUpStoredObjectInfo(XrSdkLogObjectInfo const& info); + + //! Find the stored object info, if any. + //! Return nullptr if not found. + XrSdkLogObjectInfo const* LookUpStoredObjectInfo(uint64_t handle, XrObjectType type) const { + return LookUpStoredObjectInfo({handle, type}); + } + + //! Find the object name, if any, and update debug utils info accordingly. + //! Return true if found and updated. + bool LookUpObjectName(XrDebugUtilsObjectNameInfoEXT& info) const; + + //! Find the object name, if any, and update logging info accordingly. + //! Return true if found and updated. + bool LookUpObjectName(XrSdkLogObjectInfo& info) const; + + //! Is the collection empty? + bool Empty() const { return object_info_.empty(); } + + private: + // Object names that have been set for given objects + std::vector<XrSdkLogObjectInfo> object_info_; +}; + +struct XrSdkSessionLabel; +using XrSdkSessionLabelPtr = std::unique_ptr<XrSdkSessionLabel>; +using XrSdkSessionLabelList = std::vector<XrSdkSessionLabelPtr>; + +struct XrSdkSessionLabel { + static XrSdkSessionLabelPtr make(const XrDebugUtilsLabelEXT& label_info, bool individual); + + std::string label_name; + XrDebugUtilsLabelEXT debug_utils_label; + bool is_individual_label; + + private: + XrSdkSessionLabel(const XrDebugUtilsLabelEXT& label_info, bool individual); +}; + +/// The metadata for a collection of objects. Must persist unmodified during the entire debug messenger call! +struct NamesAndLabels { + NamesAndLabels() = default; + NamesAndLabels(std::vector<XrSdkLogObjectInfo> obj, std::vector<XrDebugUtilsLabelEXT> lab); + /// C++ structure owning the data (strings) backing the objects vector. + std::vector<XrSdkLogObjectInfo> sdk_objects; + + std::vector<XrDebugUtilsObjectNameInfoEXT> objects; + std::vector<XrDebugUtilsLabelEXT> labels; + + /// Populate the debug utils callback data structure. + void PopulateCallbackData(XrDebugUtilsMessengerCallbackDataEXT& data) const; + // XrDebugUtilsMessengerCallbackDataEXT MakeCallbackData() const; +}; + +struct AugmentedCallbackData { + std::vector<XrDebugUtilsLabelEXT> labels; + std::vector<XrDebugUtilsObjectNameInfoEXT> new_objects; + XrDebugUtilsMessengerCallbackDataEXT modified_data; + const XrDebugUtilsMessengerCallbackDataEXT* exported_data; +}; + +/// Tracks all the data (handle names and session labels) required to fully augment XR_EXT_debug_utils-related calls. +class DebugUtilsData { + public: + DebugUtilsData() = default; + + DebugUtilsData(const DebugUtilsData&) = delete; + DebugUtilsData& operator=(const DebugUtilsData&) = delete; + + bool Empty() const { return object_info_.Empty() && session_labels_.empty(); } + + //! Core of implementation for xrSetDebugUtilsObjectNameEXT + void AddObjectName(uint64_t object_handle, XrObjectType object_type, const std::string& object_name); + + /// Core of implementation for xrSessionBeginDebugUtilsLabelRegionEXT + void BeginLabelRegion(XrSession session, const XrDebugUtilsLabelEXT& label_info); + + /// Core of implementation for xrSessionEndDebugUtilsLabelRegionEXT + void EndLabelRegion(XrSession session); + + /// Core of implementation for xrSessionInsertDebugUtilsLabelEXT + void InsertLabel(XrSession session, const XrDebugUtilsLabelEXT& label_info); + + /// Removes all labels associated with a session - call in xrDestroySession and xrDestroyInstance (for all child sessions) + void DeleteSessionLabels(XrSession session); + + /// Retrieve labels for the given session, if any, and push them in reverse order on the vector. + void LookUpSessionLabels(XrSession session, std::vector<XrDebugUtilsLabelEXT>& labels) const; + + /// Removes all data related to this object - including session labels if it's a session. + /// + /// Does not take care of handling child objects - you must do this yourself. + void DeleteObject(uint64_t object_handle, XrObjectType object_type); + + /// Given the collection of objects, populate their names and list of labels + NamesAndLabels PopulateNamesAndLabels(std::vector<XrSdkLogObjectInfo> objects) const; + + void WrapCallbackData(AugmentedCallbackData* aug_data, + const XrDebugUtilsMessengerCallbackDataEXT* provided_callback_data) const; + + private: + void RemoveIndividualLabel(XrSdkSessionLabelList& label_vec); + XrSdkSessionLabelList* GetSessionLabelList(XrSession session); + XrSdkSessionLabelList& GetOrCreateSessionLabelList(XrSession session); + + // Session labels: one vector of them per session. + std::unordered_map<XrSession, std::unique_ptr<XrSdkSessionLabelList>> session_labels_; + + // Names for objects. + ObjectInfoCollection object_info_; +}; diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/common/platform_exports.h b/shadps4-arm64-main/externals/openxr-sdk/src/common/platform_exports.h new file mode 100644 index 0000000..6b7d5cf --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/common/platform_exports.h @@ -0,0 +1,14 @@ +// Copyright (c) 2017-2026 The Khronos Group Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// + +#if defined(__GNUC__) && __GNUC__ >= 4 +#define PLATFORM_EXPORT __attribute__((visibility("default"))) +#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590) +#define PLATFORM_EXPORT __attribute__((visibility("default"))) +#elif defined(_WIN32) +#define PLATFORM_EXPORT __declspec(dllexport) +#else +#define PLATFORM_EXPORT +#endif diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/common/platform_utils.hpp b/shadps4-arm64-main/externals/openxr-sdk/src/common/platform_utils.hpp new file mode 100644 index 0000000..52aac68 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/common/platform_utils.hpp @@ -0,0 +1,417 @@ +// Copyright (c) 2017-2026 The Khronos Group Inc. +// Copyright (c) 2017-2019 Valve Corporation +// Copyright (c) 2017-2019 LunarG, Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// +// Initial Authors: Mark Young <marky@lunarg.com>, Dave Houlton <daveh@lunarg.com> +// + +#pragma once + +#include "xr_dependencies.h" +#include <string> +#include <stdint.h> +#include <stdlib.h> + +// OpenXR paths and registry key locations +#define OPENXR_RELATIVE_PATH "openxr/" +#define OPENXR_IMPLICIT_API_LAYER_RELATIVE_PATH "/api_layers/implicit.d" +#define OPENXR_EXPLICIT_API_LAYER_RELATIVE_PATH "/api_layers/explicit.d" +#ifdef XR_OS_WINDOWS +#define OPENXR_REGISTRY_LOCATION "SOFTWARE\\Khronos\\OpenXR\\" +#define OPENXR_IMPLICIT_API_LAYER_REGISTRY_LOCATION "\\ApiLayers\\Implicit" +#define OPENXR_EXPLICIT_API_LAYER_REGISTRY_LOCATION "\\ApiLayers\\Explicit" +#endif + +// OpenXR Loader environment variables of interest +#define OPENXR_RUNTIME_JSON_ENV_VAR "XR_RUNTIME_JSON" +#define OPENXR_API_LAYER_PATH_ENV_VAR "XR_API_LAYER_PATH" + +// This is a CMake generated file with #defines for any functions/includes +// that it found present and build-time configuration. +// If you don't have this file, on non-Windows you'll need to define +// one of HAVE_SECURE_GETENV or HAVE___SECURE_GETENV depending on which +// of secure_getenv or __secure_getenv are present +#ifdef OPENXR_HAVE_COMMON_CONFIG +#include "common_config.h" +#endif // OPENXR_HAVE_COMMON_CONFIG + +#if defined(__x86_64__) && defined(__ILP32__) +#define XR_ARCH_ABI "x32" +#elif defined(_M_X64) || defined(__x86_64__) +#define XR_ARCH_ABI "x86_64" +#elif defined(_M_IX86) || defined(__i386__) || defined(_X86_) +#define XR_ARCH_ABI "i686" +#elif (defined(__aarch64__) && defined(__LP64__)) || defined(_M_ARM64) +#define XR_ARCH_ABI "aarch64" +#elif (defined(__ARM_ARCH) && __ARM_ARCH >= 7 && (defined(__ARM_PCS_VFP) || defined(__ANDROID__))) || defined(_M_ARM) +#define XR_ARCH_ABI "armv7a-vfp" +#elif defined(__ARM_ARCH_5TE__) || (defined(__ARM_ARCH) && __ARM_ARCH > 5) +#define XR_ARCH_ABI "armv5te" +#elif defined(__mips64) +#define XR_ARCH_ABI "mips64" +#elif defined(__mips) +#define XR_ARCH_ABI "mips" +#elif defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ +#define XR_ARCH_ABI "ppc64" +#elif defined(__powerpc__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ +#define XR_ARCH_ABI "ppc64el" +#elif defined(__s390x__) || defined(__zarch__) +#define XR_ARCH_ABI "s390x" +#elif defined(__hppa__) +#define XR_ARCH_ABI "hppa" +#elif defined(__alpha__) +#define XR_ARCH_ABI "alpha" +#elif defined(__ia64__) || defined(_M_IA64) +#define XR_ARCH_ABI "ia64" +#elif defined(__m68k__) +#define XR_ARCH_ABI "m68k" +#elif defined(__riscv_xlen) && (__riscv_xlen == 64) +#define XR_ARCH_ABI "riscv64" +#elif defined(__sparc__) && defined(__arch64__) +#define XR_ARCH_ABI "sparc64" +#elif defined(__loongarch64) +#define XR_ARCH_ABI "loongarch64" +#else +#error "No architecture string known!" +#endif + +// Consumers of this file must ensure this function is implemented. For example, the loader will implement this function so that it +// can route messages through the loader's logging system. +void LogPlatformUtilsError(const std::string& message); + +// Environment variables +#if defined(XR_OS_LINUX) || defined(XR_OS_APPLE) + +#include <unistd.h> +#include <fcntl.h> +#include <iostream> +#include <sys/stat.h> + +namespace detail { + +static inline char* ImplGetEnv(const char* name) { return getenv(name); } + +// clang-format off +static inline char* ImplGetSecureEnv(const char* name) { +#ifdef HAVE_SECURE_GETENV + return secure_getenv(name); +#elif defined(HAVE___SECURE_GETENV) + return __secure_getenv(name); +#else +// NOLINTNEXTLINE(clang-diagnostic-#pragma-messages) +#pragma message( \ + "Warning: Falling back to non-secure getenv for environmental" \ + "lookups! Consider updating to a different libc.") + + return ImplGetEnv(name); +#endif +} +// clang-format on + +} // namespace detail + +#endif // defined(XR_OS_LINUX) || defined(XR_OS_APPLE) + +#if defined(XR_OS_ANDROID) || defined(XR_OS_APPLE) + +#include <sys/stat.h> + +namespace detail { + +static inline bool ImplTryRuntimeFilename(const char* rt_dir_prefix, uint16_t major_version, std::string& file_name) { + auto decorated_path = rt_dir_prefix + std::to_string(major_version) + "/active_runtime." XR_ARCH_ABI ".json"; + auto undecorated_path = rt_dir_prefix + std::to_string(major_version) + "/active_runtime.json"; + + struct stat buf {}; + if (0 == stat(decorated_path.c_str(), &buf)) { + file_name = decorated_path; + return true; + } + if (0 == stat(undecorated_path.c_str(), &buf)) { + file_name = undecorated_path; + return true; + } + return false; +} + +} // namespace detail +#endif // defined(XR_OS_ANDROID) || defined(XR_OS_APPLE) +#if defined(XR_OS_LINUX) + +static inline std::string PlatformUtilsGetEnv(const char* name) { + auto str = detail::ImplGetEnv(name); + if (str == nullptr) { + return {}; + } + return str; +} + +static inline std::string PlatformUtilsGetSecureEnv(const char* name) { + auto str = detail::ImplGetSecureEnv(name); + if (str == nullptr) { + str = detail::ImplGetEnv(name); + if (str != nullptr && !std::string(str).empty()) { + LogPlatformUtilsError(std::string("!!! WARNING !!! Environment variable ") + name + + " is being ignored due to running with secure execution. The value '" + str + + "' will NOT be used."); + } + return {}; + } + return str; +} + +static inline bool PlatformUtilsGetEnvSet(const char* name) { return detail::ImplGetEnv(name) != nullptr; } + +#elif defined(XR_OS_APPLE) + +static inline std::string PlatformUtilsGetEnv(const char* name) { + auto str = detail::ImplGetEnv(name); + if (str == nullptr) { + return {}; + } + return str; +} + +static inline std::string PlatformUtilsGetSecureEnv(const char* name) { + auto str = detail::ImplGetSecureEnv(name); + if (str == nullptr) { + return {}; + } + return str; +} + +static inline bool PlatformUtilsGetEnvSet(const char* name) { return detail::ImplGetEnv(name) != nullptr; } + +static inline bool PlatformGetGlobalRuntimeFileName(uint16_t major_version, std::string& file_name) { + return detail::ImplTryRuntimeFilename("/usr/local/share/openxr/", major_version, file_name); +} + +#elif defined(XR_OS_WINDOWS) + +inline std::wstring utf8_to_wide(const std::string& utf8Text) { + if (utf8Text.empty()) { + return {}; + } + + std::wstring wideText; + const int wideLength = ::MultiByteToWideChar(CP_UTF8, 0, utf8Text.data(), (int)utf8Text.size(), nullptr, 0); + if (wideLength == 0) { + LogPlatformUtilsError("utf8_to_wide get size error: " + std::to_string(::GetLastError())); + return {}; + } + + // MultiByteToWideChar returns number of chars of the input buffer, regardless of null terminator + wideText.resize(wideLength, 0); + wchar_t* wideString = const_cast<wchar_t*>(wideText.data()); // mutable data() only exists in c++17 + const int length = ::MultiByteToWideChar(CP_UTF8, 0, utf8Text.data(), (int)utf8Text.size(), wideString, wideLength); + if (length != wideLength) { + LogPlatformUtilsError("utf8_to_wide convert string error: " + std::to_string(::GetLastError())); + return {}; + } + + return wideText; +} + +inline std::string wide_to_utf8(const std::wstring& wideText) { + if (wideText.empty()) { + return {}; + } + + std::string narrowText; + int narrowLength = ::WideCharToMultiByte(CP_UTF8, 0, wideText.data(), (int)wideText.size(), nullptr, 0, nullptr, nullptr); + if (narrowLength == 0) { + LogPlatformUtilsError("wide_to_utf8 get size error: " + std::to_string(::GetLastError())); + return {}; + } + + // WideCharToMultiByte returns number of chars of the input buffer, regardless of null terminator + narrowText.resize(narrowLength, 0); + char* narrowString = const_cast<char*>(narrowText.data()); // mutable data() only exists in c++17 + const int length = + ::WideCharToMultiByte(CP_UTF8, 0, wideText.data(), (int)wideText.size(), narrowString, narrowLength, nullptr, nullptr); + if (length != narrowLength) { + LogPlatformUtilsError("wide_to_utf8 convert string error: " + std::to_string(::GetLastError())); + return {}; + } + + return narrowText; +} + +// Returns true if the current process has an integrity level > SECURITY_MANDATORY_MEDIUM_RID. +static inline bool IsHighIntegrityLevel() { + // Execute this check once and save the value as a static bool. + static bool isHighIntegrityLevel = ([] { + HANDLE processToken; + if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY | TOKEN_QUERY_SOURCE, &processToken)) { + // Maximum possible size of SID_AND_ATTRIBUTES is maximum size of a SID + size of attributes DWORD. + uint8_t mandatoryLabelBuffer[SECURITY_MAX_SID_SIZE + sizeof(DWORD)]{}; + DWORD bufferSize; + if (GetTokenInformation(processToken, TokenIntegrityLevel, mandatoryLabelBuffer, sizeof(mandatoryLabelBuffer), + &bufferSize) != 0) { + const auto mandatoryLabel = reinterpret_cast<const TOKEN_MANDATORY_LABEL*>(mandatoryLabelBuffer); + if (mandatoryLabel->Label.Sid != 0) { + const DWORD subAuthorityCount = *GetSidSubAuthorityCount(mandatoryLabel->Label.Sid); + const DWORD integrityLevel = *GetSidSubAuthority(mandatoryLabel->Label.Sid, subAuthorityCount - 1); + CloseHandle(processToken); + return integrityLevel > SECURITY_MANDATORY_MEDIUM_RID; + } + } + + CloseHandle(processToken); + } + + return false; + })(); + + return isHighIntegrityLevel; +} + +// Returns true if the given environment variable exists. +// The name is a case-sensitive UTF8 string. +static inline bool PlatformUtilsGetEnvSet(const char* name) { + const std::wstring wname = utf8_to_wide(name); + const DWORD valSize = ::GetEnvironmentVariableW(wname.c_str(), nullptr, 0); + // GetEnvironmentVariable returns 0 when environment variable does not exist or there is an error. + return 0 != valSize; +} + +// Returns the environment variable value for the given name. +// Returns an empty string if the environment variable doesn't exist or if it exists but is empty. +// Use PlatformUtilsGetEnvSet to tell if it exists. +// The name is a case-sensitive UTF8 string. +static inline std::string PlatformUtilsGetEnv(const char* name) { + const std::wstring wname = utf8_to_wide(name); + const DWORD valSize = ::GetEnvironmentVariableW(wname.c_str(), nullptr, 0); + // GetEnvironmentVariable returns 0 when environment variable does not exist or there is an error. + // The size includes the null-terminator, so a size of 1 is means the variable was explicitly set to empty. + if (valSize == 0 || valSize == 1) { + return {}; + } + + // GetEnvironmentVariable returns size including null terminator for "query size" call. + std::wstring wValue(valSize, 0); + wchar_t* wValueData = &wValue[0]; + + // GetEnvironmentVariable returns string length, excluding null terminator for "get value" + // call if there was enough capacity. Else it returns the required capacity (including null terminator). + const DWORD length = ::GetEnvironmentVariableW(wname.c_str(), wValueData, (DWORD)wValue.size()); + if ((length == 0) || (length >= wValue.size())) { // If error or the variable increased length between calls... + LogPlatformUtilsError("GetEnvironmentVariable get value error: " + std::to_string(::GetLastError())); + return {}; + } + + wValue.resize(length); // Strip the null terminator. + + return wide_to_utf8(wValue); +} + +// Acts the same as PlatformUtilsGetEnv except returns an empty string if IsHighIntegrityLevel. +static inline std::string PlatformUtilsGetSecureEnv(const char* name) { + // No secure version for Windows so the below integrity check is needed. + const std::string envValue = PlatformUtilsGetEnv(name); + + // Do not allow high integrity processes to act on data that can be controlled by medium integrity processes. + // Specifically, medium integrity processes can set environment variables which could then + // be read by high integrity processes. + if (IsHighIntegrityLevel()) { + if (!envValue.empty()) { + LogPlatformUtilsError(std::string("!!! WARNING !!! Environment variable ") + name + + " is being ignored due to running from an elevated context. The value '" + envValue + + "' will NOT be used."); + } + return {}; + } + + return envValue; +} + +#elif defined(XR_OS_ANDROID) + +#include <sys/system_properties.h> + +static inline bool PlatformUtilsGetEnvSet(const char* /* name */) { + // Stub func + return false; +} + +static inline std::string PlatformUtilsGetEnv(const char* /* name */) { + // Stub func + return {}; +} + +static inline std::string PlatformUtilsGetSecureEnv(const char* /* name */) { + // Stub func + return {}; +} + +// Intended to be only used as a fallback on Android, with a more open, "native" technique used in most cases +static inline bool PlatformGetGlobalRuntimeFileName(uint16_t major_version, std::string& file_name) { + // Prefix for the runtime JSON file name + static const char* rt_dir_prefixes[] = {"/product", "/odm", "/oem", "/vendor", "/system"}; + + static const std::string subdir = "/etc/openxr/"; + for (const auto prefix : rt_dir_prefixes) { + const std::string rt_dir_prefix = prefix + subdir; + if (detail::ImplTryRuntimeFilename(rt_dir_prefix.c_str(), major_version, file_name)) { + return true; + } + } + + return false; +} + +// Android system properties are sufficiently different from environment variables that we are not reusing +// PlatformUtilsGetEnv for this purpose +static inline std::string PlatformUtilsGetAndroidSystemProperty(const char* name) { + std::string result; + const prop_info* pi = __system_property_find(name); + if (pi == nullptr) { + return {}; + } + +#if __ANDROID_API__ >= 26 + // use callback to retrieve > 92 character sys prop values, if available + __system_property_read_callback( + pi, + [](void* cookie, const char*, const char* value, uint32_t) { + auto property_value = reinterpret_cast<std::string*>(cookie); + *property_value = value; + }, + reinterpret_cast<void*>(&result)); +#endif // __ANDROID_API__ >= 26 + // fallback to __system_property_get if no value retrieved via callback + if (result.empty()) { + char value[PROP_VALUE_MAX] = {}; + if (__system_property_get(name, value) != 0) { + result = value; + } + } + + return result; +} + +#else // Not Linux, Apple, nor Windows + +static inline bool PlatformUtilsGetEnvSet(const char* /* name */) { + // Stub func + return false; +} + +static inline std::string PlatformUtilsGetEnv(const char* /* name */) { + // Stub func + return {}; +} + +static inline std::string PlatformUtilsGetSecureEnv(const char* /* name */) { + // Stub func + return {}; +} + +static inline bool PlatformGetGlobalRuntimeFileName(uint16_t /* major_version */, std::string const& /* file_name */) { + // Stub func + return false; +} + +#endif diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/common/stdfs_conditions.h b/shadps4-arm64-main/externals/openxr-sdk/src/common/stdfs_conditions.h new file mode 100644 index 0000000..eb76943 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/common/stdfs_conditions.h @@ -0,0 +1,45 @@ +// Copyright (c) 2017-2026 The Khronos Group Inc. +// Copyright (c) 2017 Valve Corporation +// Copyright (c) 2017 LunarG, Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT + +#ifndef _STDFS_CONDITIONS_H +#define _STDFS_CONDITIONS_H + +// If the C++ macro is set to the version containing C++17, it must support +// the final C++17 package +#if __cplusplus >= 201703L +#define USE_EXPERIMENTAL_FS 0 +#define USE_FINAL_FS 1 + +#elif defined(_MSC_VER) && _MSC_VER >= 1900 + +#if defined(_HAS_CXX17) && _HAS_CXX17 +// When MSC supports c++17 use <filesystem> package. +#define USE_EXPERIMENTAL_FS 0 +#define USE_FINAL_FS 1 +#endif // !_HAS_CXX17 + +// GCC supports the experimental filesystem items starting in GCC 6 +#elif (__GNUC__ >= 6) +#define USE_EXPERIMENTAL_FS 1 +#define USE_FINAL_FS 0 + +// If Clang, check for feature support +#elif defined(__clang__) && (defined(__cpp_lib_filesystem) || defined(__cpp_lib_experimental_filesystem)) +#if __cpp_lib_filesystem +#define USE_EXPERIMENTAL_FS 0 +#define USE_FINAL_FS 1 +#else +#define USE_EXPERIMENTAL_FS 1 +#define USE_FINAL_FS 0 +#endif + +// If all above fails, fall back to standard C++ and OS-specific items +#else +#define USE_EXPERIMENTAL_FS 0 +#define USE_FINAL_FS 0 +#endif + +#endif // !_STDFS_CONDITIONS_H diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/common/unique_asset.h b/shadps4-arm64-main/externals/openxr-sdk/src/common/unique_asset.h new file mode 100644 index 0000000..f822f86 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/common/unique_asset.h @@ -0,0 +1,33 @@ +// Copyright (c) 2017-2026 The Khronos Group Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +#pragma once + +#ifdef XR_USE_PLATFORM_ANDROID + +#include <memory> +#include <android/asset_manager.h> + +namespace deleters { +struct AAssetDeleter { + void operator()(AAsset* asset) const noexcept { + if (asset != nullptr) { + AAsset_close(asset); + } + } +}; + +struct AAssetDirDeleter { + void operator()(AAssetDir* dir) const noexcept { + if (dir != nullptr) { + AAssetDir_close(dir); + } + } +}; + +} // namespace deleters + +using UniqueAsset = std::unique_ptr<AAsset, deleters::AAssetDeleter>; +using UniqueAssetDir = std::unique_ptr<AAssetDir, deleters::AAssetDirDeleter>; + +#endif diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/common/vulkan_debug_object_namer.hpp b/shadps4-arm64-main/externals/openxr-sdk/src/common/vulkan_debug_object_namer.hpp new file mode 100644 index 0000000..96acc8a --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/common/vulkan_debug_object_namer.hpp @@ -0,0 +1,63 @@ +// Copyright (c) 2017-2026 The Khronos Group Inc. +// +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#ifdef XR_USE_GRAPHICS_API_VULKAN + +#include <vulkan/vulkan_core.h> +#include <stdexcept> + +/// Utility class for assigning debug names to Vulkan objects we create. +class VulkanDebugObjectNamer { + public: + /// Construct without initializing + VulkanDebugObjectNamer() = default; + + /// Construct and initialize + VulkanDebugObjectNamer(VkInstance instance, VkDevice device) : m_vkDevice{device} { + vkSetDebugUtilsObjectNameEXT = + (PFN_vkSetDebugUtilsObjectNameEXT)vkGetInstanceProcAddr(instance, "vkSetDebugUtilsObjectNameEXT"); + } + /// Copy constructor + VulkanDebugObjectNamer(const VulkanDebugObjectNamer&) = default; + /// Copy assignment operator + VulkanDebugObjectNamer& operator=(const VulkanDebugObjectNamer&) = default; + + /// Destructor + ~VulkanDebugObjectNamer() { Reset(); } + + /// (Re-) Initialize the namer: takes a valid `VkInstance` and `VkDevice` + void Init(VkInstance instance, VkDevice device) { + Reset(); + *this = VulkanDebugObjectNamer(instance, device); + } + + /// The main operation of the namer: actually set an object name. + /// + /// If the namer is not initialized, this exits silently. + VkResult SetName(VkObjectType objectType, uint64_t objectHandle, const char* pObjectName) const { + if (m_vkDevice == nullptr) { + return VK_SUCCESS; + } + if (vkSetDebugUtilsObjectNameEXT != nullptr) { + VkDebugUtilsObjectNameInfoEXT nameInfo{VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT, nullptr, objectType, + objectHandle, pObjectName}; + return vkSetDebugUtilsObjectNameEXT(m_vkDevice, &nameInfo); + } + return VK_SUCCESS; + } + + /// De-initialize the namer, forgetting the device and the function pointer loaded from the instance. + void Reset() { + vkSetDebugUtilsObjectNameEXT = nullptr; + m_vkDevice = VK_NULL_HANDLE; + } + + private: + VkDevice m_vkDevice{VK_NULL_HANDLE}; + PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT{nullptr}; +}; + +#endif diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/common/xr_dependencies.h b/shadps4-arm64-main/externals/openxr-sdk/src/common/xr_dependencies.h new file mode 100644 index 0000000..227e388 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/common/xr_dependencies.h @@ -0,0 +1,103 @@ +// Copyright (c) 2018-2026 The Khronos Group Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// +// This file includes headers with types which openxr.h depends on in order +// to compile when platforms, graphics apis, and the like are enabled. + +#pragma once + +#ifdef XR_USE_PLATFORM_ANDROID +#include <android/native_window.h> +#include <android/window.h> +#include <android/native_window_jni.h> +#endif // XR_USE_PLATFORM_ANDROID + +#ifdef XR_USE_PLATFORM_WIN32 + +#include <winapifamily.h> +#if !(WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP | WINAPI_PARTITION_SYSTEM)) +// Enable desktop partition APIs, such as RegOpenKeyEx, LoadLibraryEx, PathFileExists etc. +#undef WINAPI_PARTITION_DESKTOP +#define WINAPI_PARTITION_DESKTOP 1 +#endif + +#ifndef NOMINMAX +#define NOMINMAX +#endif // !NOMINMAX + +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#endif // !WIN32_LEAN_AND_MEAN + +#include <windows.h> +#include <unknwn.h> + +#endif // XR_USE_PLATFORM_WIN32 + +#ifdef XR_USE_GRAPHICS_API_D3D11 +#include <d3d11.h> +#endif // XR_USE_GRAPHICS_API_D3D11 + +#ifdef XR_USE_GRAPHICS_API_D3D12 +#include <d3d12.h> +#endif // XR_USE_GRAPHICS_API_D3D12 + +#ifdef XR_USE_PLATFORM_XLIB +#include <X11/Xlib.h> +#include <X11/Xutil.h> +#endif // XR_USE_PLATFORM_XLIB + +#ifdef XR_USE_PLATFORM_XCB +#include <xcb/xcb.h> +#endif // XR_USE_PLATFORM_XCB + +#if defined(XR_USE_GRAPHICS_API_OPENGL_ES) || defined(XR_USE_PLATFORM_EGL) +#ifdef XRDEPENDENCIES_USE_GLAD +#include <glad/egl.h> +#else +#include <EGL/egl.h> +#endif +#endif // XR_USE_GRAPHICS_API_OPENGL_ES || XR_USE_PLATFORM_EGL + +#if defined(XR_USE_GRAPHICS_API_OPENGL) && (defined(XR_USE_PLATFORM_XLIB) || defined(XR_USE_PLATFORM_XCB)) +#ifdef XRDEPENDENCIES_USE_GLAD +#include <glad/glx.h> +#else +#include <GL/glx.h> +#endif +#endif // XR_USE_GRAPHICS_API_OPENGL && XR_USE_PLATFORM_XLIB || XR_USE_PLATFORM_XCB + +#if defined(XR_USE_GRAPHICS_API_OPENGL) && defined(XR_USE_PLATFORM_XCB) +#include <xcb/glx.h> +#endif // XR_USE_GRAPHICS_API_OPENGL && XR_USE_PLATFORM_XCB + +#if defined(XR_USE_GRAPHICS_API_OPENGL) && defined(XR_USE_PLATFORM_MACOS) && !defined(XRDEPENDENCIES_USE_GLAD) +#include <OpenCL/cl_gl_ext.h> +#endif // XR_USE_GRAPHICS_API_OPENGL && XR_USE_PLATFORM_MACOS && !XRDEPENDENCIES_USE_GLAD + +#ifdef XR_USE_GRAPHICS_API_VULKAN +#include <vulkan/vulkan.h> +#endif // XR_USE_GRAPHICS_API_VULKAN + +#ifdef XR_USE_PLATFORM_WAYLAND +#include <wayland-client.h> +#endif // XR_USE_PLATFORM_WAYLAND + +#if defined(XR_USE_PLATFORM_XLIB) || defined(XR_USE_PLATFORM_XCB) || defined(XR_USE_PLATFORM_EGL) +#ifdef Success +#undef Success +#endif // Success + +#ifdef Always +#undef Always +#endif // Always + +#ifdef None +#undef None +#endif // None +#endif // defined(XR_USE_PLATFORM_XLIB) || defined(XR_USE_PLATFORM_XCB) + +#ifdef XR_USE_TIMESPEC +#include <time.h> +#endif // XR_USE_TIMESPEC diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/common/xr_linear.h b/shadps4-arm64-main/externals/openxr-sdk/src/common/xr_linear.h new file mode 100644 index 0000000..17b3cd6 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/common/xr_linear.h @@ -0,0 +1,869 @@ +// Copyright (c) 2017-2026 The Khronos Group Inc. +// Copyright (c) 2016, Oculus VR, LLC. +// +// SPDX-License-Identifier: Apache-2.0 +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// Author: J.M.P. van Waveren +// + +#ifndef XR_LINEAR_H_ +#define XR_LINEAR_H_ + +#include <openxr/openxr.h> + +/* REUSE-IgnoreStart */ +/* The following has copyright notices that duplicate the header above */ + +/* +================================================================================================ + +Description : Vector, matrix and quaternion math. +Orig. Author : J.M.P. van Waveren +Orig. Date : 12/10/2016 +Language : C99 +Copyright : Copyright (c) 2016 Oculus VR, LLC. All Rights reserved. + + +DESCRIPTION +=========== + +All matrices are column-major. + +INTERFACE +========= + +XrVector2f +XrVector3f +XrVector4f +XrQuaternionf +XrPosef +XrMatrix4x4f + +inline static void XrVector3f_Set(XrVector3f* v, const float value); +inline static void XrVector3f_Add(XrVector3f* result, const XrVector3f* a, const XrVector3f* b); +inline static void XrVector3f_Sub(XrVector3f* result, const XrVector3f* a, const XrVector3f* b); +inline static void XrVector3f_Min(XrVector3f* result, const XrVector3f* a, const XrVector3f* b); +inline static void XrVector3f_Max(XrVector3f* result, const XrVector3f* a, const XrVector3f* b); +inline static void XrVector3f_Decay(XrVector3f* result, const XrVector3f* a, const float value); +inline static void XrVector3f_Lerp(XrVector3f* result, const XrVector3f* a, const XrVector3f* b, const float fraction); +inline static void XrVector3f_Scale(XrVector3f* result, const XrVector3f* a, const float scaleFactor); +inline static void XrVector3f_Normalize(XrVector3f* v); +inline static float XrVector3f_Length(const XrVector3f* v); + +inline static void XrQuaternionf_CreateIdentity(XrQuaternionf* q); +inline static void XrQuaternionf_CreateFromAxisAngle(XrQuaternionf* result, const XrVector3f* axis, const float angleInRadians); +inline static void XrQuaternionf_Lerp(XrQuaternionf* result, const XrQuaternionf* a, const XrQuaternionf* b, const float fraction); +inline static void XrQuaternionf_Multiply(XrQuaternionf* result, const XrQuaternionf* a, const XrQuaternionf* b); +inline static void XrQuaternionf_Invert(XrQuaternionf* result, const XrQuaternionf* q); +inline static void XrQuaternionf_Normalize(XrQuaternionf* q); +inline static void XrQuaternionf_RotateVector3f(XrVector3f* result, const XrQuaternionf* a, const XrVector3f* v); + +inline static void XrPosef_CreateIdentity(XrPosef* result); +inline static void XrPosef_TransformVector3f(XrVector3f* result, const XrPosef* a, const XrVector3f* v); +inline static void XrPosef_Multiply(XrPosef* result, const XrPosef* a, const XrPosef* b); +inline static void XrPosef_Invert(XrPosef* result, const XrPosef* a); + +inline static void XrMatrix4x4f_CreateIdentity(XrMatrix4x4f* result); +inline static void XrMatrix4x4f_CreateTranslation(XrMatrix4x4f* result, const float x, const float y, const float z); +inline static void XrMatrix4x4f_CreateRotation(XrMatrix4x4f* result, const float degreesX, const float degreesY, + const float degreesZ); +inline static void XrMatrix4x4f_CreateScale(XrMatrix4x4f* result, const float x, const float y, const float z); +inline static void XrMatrix4x4f_CreateTranslationRotationScale(XrMatrix4x4f* result, const XrVector3f* translation, + const XrQuaternionf* rotation, const XrVector3f* scale); +inline static void XrMatrix4x4f_CreateFromRigidTransform(XrMatrix4x4f* result, const XrPosef* s); +inline static void XrMatrix4x4f_CreateProjection(XrMatrix4x4f* result, GraphicsAPI graphicsApi, const float tanAngleLeft, + const float tanAngleRight, const float tanAngleUp, float const tanAngleDown, + const float nearZ, const float farZ); +inline static void XrMatrix4x4f_CreateProjectionFov(XrMatrix4x4f* result, GraphicsAPI graphicsApi, const XrFovf fov, + const float nearZ, const float farZ); +inline static void XrMatrix4x4f_CreateFromQuaternion(XrMatrix4x4f* result, const XrQuaternionf* quat); +inline static void XrMatrix4x4f_CreateOffsetScaleForBounds(XrMatrix4x4f* result, const XrMatrix4x4f* matrix, const XrVector3f* mins, + const XrVector3f* maxs); + +inline static bool XrMatrix4x4f_IsAffine(const XrMatrix4x4f* matrix, const float epsilon); +inline static bool XrMatrix4x4f_IsOrthogonal(const XrMatrix4x4f* matrix, const float epsilon); +inline static bool XrMatrix4x4f_IsOrthonormal(const XrMatrix4x4f* matrix, const float epsilon); +inline static bool XrMatrix4x4f_IsRigidBody(const XrMatrix4x4f* matrix, const float epsilon); + +inline static void XrMatrix4x4f_GetTranslation(XrVector3f* result, const XrMatrix4x4f* src); +inline static void XrMatrix4x4f_GetRotation(XrQuaternionf* result, const XrMatrix4x4f* src); +inline static void XrMatrix4x4f_GetScale(XrVector3f* result, const XrMatrix4x4f* src); + +inline static void XrMatrix4x4f_Multiply(XrMatrix4x4f* result, const XrMatrix4x4f* a, const XrMatrix4x4f* b); +inline static void XrMatrix4x4f_Transpose(XrMatrix4x4f* result, const XrMatrix4x4f* src); +inline static void XrMatrix4x4f_Invert(XrMatrix4x4f* result, const XrMatrix4x4f* src); +inline static void XrMatrix4x4f_InvertRigidBody(XrMatrix4x4f* result, const XrMatrix4x4f* src); + +inline static void XrMatrix4x4f_TransformVector3f(XrVector3f* result, const XrMatrix4x4f* m, const XrVector3f* v); +inline static void XrMatrix4x4f_TransformVector4f(XrVector4f* result, const XrMatrix4x4f* m, const XrVector4f* v); + +inline static void XrMatrix4x4f_TransformBounds(XrVector3f* resultMins, XrVector3f* resultMaxs, const XrMatrix4x4f* matrix, + const XrVector3f* mins, const XrVector3f* maxs); +inline static bool XrMatrix4x4f_CullBounds(const XrMatrix4x4f* mvp, const XrVector3f* mins, const XrVector3f* maxs); + +================================================================================================ +*/ + +#include <assert.h> +#include <math.h> +#include <stdbool.h> + +#define MATH_PI 3.14159265358979323846f + +#define DEFAULT_NEAR_Z 0.015625f // exact floating point representation +#define INFINITE_FAR_Z 0.0f + +static const XrColor4f XrColorRed = {1.0f, 0.0f, 0.0f, 1.0f}; +static const XrColor4f XrColorGreen = {0.0f, 1.0f, 0.0f, 1.0f}; +static const XrColor4f XrColorBlue = {0.0f, 0.0f, 1.0f, 1.0f}; +static const XrColor4f XrColorYellow = {1.0f, 1.0f, 0.0f, 1.0f}; +static const XrColor4f XrColorPurple = {1.0f, 0.0f, 1.0f, 1.0f}; +static const XrColor4f XrColorCyan = {0.0f, 1.0f, 1.0f, 1.0f}; +static const XrColor4f XrColorLightGrey = {0.7f, 0.7f, 0.7f, 1.0f}; +static const XrColor4f XrColorDarkGrey = {0.3f, 0.3f, 0.3f, 1.0f}; + +typedef enum GraphicsAPI { GRAPHICS_VULKAN, GRAPHICS_OPENGL, GRAPHICS_OPENGL_ES, GRAPHICS_D3D, GRAPHICS_METAL } GraphicsAPI; + +// Column-major, pre-multiplied. This type does not exist in the OpenXR API and is provided for convenience. +typedef struct XrMatrix4x4f { + float m[16]; +} XrMatrix4x4f; + +inline static float XrRcpSqrt(const float x) { + const float SMALLEST_NON_DENORMAL = 1.1754943508222875e-038f; // ( 1U << 23 ) + const float rcp = (x >= SMALLEST_NON_DENORMAL) ? 1.0f / sqrtf(x) : 1.0f; + return rcp; +} + +inline static float XrVector2f_Length(const XrVector2f* v) { return sqrtf(v->x * v->x + v->y * v->y); } + +inline static void XrVector3f_Set(XrVector3f* v, const float value) { + v->x = value; + v->y = value; + v->z = value; +} + +inline static void XrVector3f_Add(XrVector3f* result, const XrVector3f* a, const XrVector3f* b) { + result->x = a->x + b->x; + result->y = a->y + b->y; + result->z = a->z + b->z; +} + +inline static void XrVector3f_Sub(XrVector3f* result, const XrVector3f* a, const XrVector3f* b) { + result->x = a->x - b->x; + result->y = a->y - b->y; + result->z = a->z - b->z; +} + +inline static void XrVector3f_Min(XrVector3f* result, const XrVector3f* a, const XrVector3f* b) { + result->x = (a->x < b->x) ? a->x : b->x; + result->y = (a->y < b->y) ? a->y : b->y; + result->z = (a->z < b->z) ? a->z : b->z; +} + +inline static void XrVector3f_Max(XrVector3f* result, const XrVector3f* a, const XrVector3f* b) { + result->x = (a->x > b->x) ? a->x : b->x; + result->y = (a->y > b->y) ? a->y : b->y; + result->z = (a->z > b->z) ? a->z : b->z; +} + +inline static void XrVector3f_Decay(XrVector3f* result, const XrVector3f* a, const float value) { + result->x = (fabsf(a->x) > value) ? ((a->x > 0.0f) ? (a->x - value) : (a->x + value)) : 0.0f; + result->y = (fabsf(a->y) > value) ? ((a->y > 0.0f) ? (a->y - value) : (a->y + value)) : 0.0f; + result->z = (fabsf(a->z) > value) ? ((a->z > 0.0f) ? (a->z - value) : (a->z + value)) : 0.0f; +} + +inline static void XrVector3f_Lerp(XrVector3f* result, const XrVector3f* a, const XrVector3f* b, const float fraction) { + result->x = a->x + fraction * (b->x - a->x); + result->y = a->y + fraction * (b->y - a->y); + result->z = a->z + fraction * (b->z - a->z); +} + +inline static void XrVector3f_Scale(XrVector3f* result, const XrVector3f* a, const float scaleFactor) { + result->x = a->x * scaleFactor; + result->y = a->y * scaleFactor; + result->z = a->z * scaleFactor; +} + +inline static float XrVector3f_Dot(const XrVector3f* a, const XrVector3f* b) { return a->x * b->x + a->y * b->y + a->z * b->z; } + +// Compute cross product, which generates a normal vector. +// Direction vector can be determined by right-hand rule: Pointing index finder in +// direction a and middle finger in direction b, thumb will point in Cross(a, b). +inline static void XrVector3f_Cross(XrVector3f* result, const XrVector3f* a, const XrVector3f* b) { + result->x = a->y * b->z - a->z * b->y; + result->y = a->z * b->x - a->x * b->z; + result->z = a->x * b->y - a->y * b->x; +} + +inline static void XrVector3f_Normalize(XrVector3f* v) { + const float lengthRcp = XrRcpSqrt(v->x * v->x + v->y * v->y + v->z * v->z); + v->x *= lengthRcp; + v->y *= lengthRcp; + v->z *= lengthRcp; +} + +inline static float XrVector3f_Length(const XrVector3f* v) { return sqrtf(v->x * v->x + v->y * v->y + v->z * v->z); } + +inline static void XrQuaternionf_CreateIdentity(XrQuaternionf* q) { + q->x = 0.0f; + q->y = 0.0f; + q->z = 0.0f; + q->w = 1.0f; +} + +inline static void XrQuaternionf_CreateFromAxisAngle(XrQuaternionf* result, const XrVector3f* axis, const float angleInRadians) { + float s = sinf(angleInRadians / 2.0f); + float lengthRcp = XrRcpSqrt(axis->x * axis->x + axis->y * axis->y + axis->z * axis->z); + result->x = s * axis->x * lengthRcp; + result->y = s * axis->y * lengthRcp; + result->z = s * axis->z * lengthRcp; + result->w = cosf(angleInRadians / 2.0f); +} + +inline static void XrQuaternionf_Lerp(XrQuaternionf* result, const XrQuaternionf* a, const XrQuaternionf* b, const float fraction) { + const float s = a->x * b->x + a->y * b->y + a->z * b->z + a->w * b->w; + const float fa = 1.0f - fraction; + const float fb = (s < 0.0f) ? -fraction : fraction; + const float x = a->x * fa + b->x * fb; + const float y = a->y * fa + b->y * fb; + const float z = a->z * fa + b->z * fb; + const float w = a->w * fa + b->w * fb; + const float lengthRcp = XrRcpSqrt(x * x + y * y + z * z + w * w); + result->x = x * lengthRcp; + result->y = y * lengthRcp; + result->z = z * lengthRcp; + result->w = w * lengthRcp; +} + +inline static void XrQuaternionf_Multiply(XrQuaternionf* result, const XrQuaternionf* a, const XrQuaternionf* b) { + result->x = (b->w * a->x) + (b->x * a->w) + (b->y * a->z) - (b->z * a->y); + result->y = (b->w * a->y) - (b->x * a->z) + (b->y * a->w) + (b->z * a->x); + result->z = (b->w * a->z) + (b->x * a->y) - (b->y * a->x) + (b->z * a->w); + result->w = (b->w * a->w) - (b->x * a->x) - (b->y * a->y) - (b->z * a->z); +} + +inline static void XrQuaternionf_Invert(XrQuaternionf* result, const XrQuaternionf* q) { + result->x = -q->x; + result->y = -q->y; + result->z = -q->z; + result->w = q->w; +} + +inline static void XrQuaternionf_Normalize(XrQuaternionf* q) { + const float lengthRcp = XrRcpSqrt(q->x * q->x + q->y * q->y + q->z * q->z + q->w * q->w); + q->x *= lengthRcp; + q->y *= lengthRcp; + q->z *= lengthRcp; + q->w *= lengthRcp; +} + +inline static void XrQuaternionf_RotateVector3f(XrVector3f* result, const XrQuaternionf* a, const XrVector3f* v) { + XrQuaternionf q = {v->x, v->y, v->z, 0.0f}; + XrQuaternionf aq; + XrQuaternionf_Multiply(&aq, &q, a); + XrQuaternionf aInv; + XrQuaternionf_Invert(&aInv, a); + XrQuaternionf aqaInv; + XrQuaternionf_Multiply(&aqaInv, &aInv, &aq); + + result->x = aqaInv.x; + result->y = aqaInv.y; + result->z = aqaInv.z; +} + +inline static void XrPosef_CreateIdentity(XrPosef* result) { + XrQuaternionf_CreateIdentity(&result->orientation); + XrVector3f_Set(&result->position, 0); +} + +inline static void XrPosef_TransformVector3f(XrVector3f* result, const XrPosef* a, const XrVector3f* v) { + XrVector3f r0; + XrQuaternionf_RotateVector3f(&r0, &a->orientation, v); + XrVector3f_Add(result, &r0, &a->position); +} + +inline static void XrPosef_Multiply(XrPosef* result, const XrPosef* a, const XrPosef* b) { + XrQuaternionf_Multiply(&result->orientation, &b->orientation, &a->orientation); + XrPosef_TransformVector3f(&result->position, a, &b->position); +} + +inline static void XrPosef_Invert(XrPosef* result, const XrPosef* a) { + XrQuaternionf_Invert(&result->orientation, &a->orientation); + XrVector3f aPosNeg; + XrVector3f_Scale(&aPosNeg, &a->position, -1.0f); + XrQuaternionf_RotateVector3f(&result->position, &result->orientation, &aPosNeg); +} + +// Use left-multiplication to accumulate transformations. +inline static void XrMatrix4x4f_Multiply(XrMatrix4x4f* result, const XrMatrix4x4f* a, const XrMatrix4x4f* b) { + result->m[0] = a->m[0] * b->m[0] + a->m[4] * b->m[1] + a->m[8] * b->m[2] + a->m[12] * b->m[3]; + result->m[1] = a->m[1] * b->m[0] + a->m[5] * b->m[1] + a->m[9] * b->m[2] + a->m[13] * b->m[3]; + result->m[2] = a->m[2] * b->m[0] + a->m[6] * b->m[1] + a->m[10] * b->m[2] + a->m[14] * b->m[3]; + result->m[3] = a->m[3] * b->m[0] + a->m[7] * b->m[1] + a->m[11] * b->m[2] + a->m[15] * b->m[3]; + + result->m[4] = a->m[0] * b->m[4] + a->m[4] * b->m[5] + a->m[8] * b->m[6] + a->m[12] * b->m[7]; + result->m[5] = a->m[1] * b->m[4] + a->m[5] * b->m[5] + a->m[9] * b->m[6] + a->m[13] * b->m[7]; + result->m[6] = a->m[2] * b->m[4] + a->m[6] * b->m[5] + a->m[10] * b->m[6] + a->m[14] * b->m[7]; + result->m[7] = a->m[3] * b->m[4] + a->m[7] * b->m[5] + a->m[11] * b->m[6] + a->m[15] * b->m[7]; + + result->m[8] = a->m[0] * b->m[8] + a->m[4] * b->m[9] + a->m[8] * b->m[10] + a->m[12] * b->m[11]; + result->m[9] = a->m[1] * b->m[8] + a->m[5] * b->m[9] + a->m[9] * b->m[10] + a->m[13] * b->m[11]; + result->m[10] = a->m[2] * b->m[8] + a->m[6] * b->m[9] + a->m[10] * b->m[10] + a->m[14] * b->m[11]; + result->m[11] = a->m[3] * b->m[8] + a->m[7] * b->m[9] + a->m[11] * b->m[10] + a->m[15] * b->m[11]; + + result->m[12] = a->m[0] * b->m[12] + a->m[4] * b->m[13] + a->m[8] * b->m[14] + a->m[12] * b->m[15]; + result->m[13] = a->m[1] * b->m[12] + a->m[5] * b->m[13] + a->m[9] * b->m[14] + a->m[13] * b->m[15]; + result->m[14] = a->m[2] * b->m[12] + a->m[6] * b->m[13] + a->m[10] * b->m[14] + a->m[14] * b->m[15]; + result->m[15] = a->m[3] * b->m[12] + a->m[7] * b->m[13] + a->m[11] * b->m[14] + a->m[15] * b->m[15]; +} + +// Creates the transpose of the given matrix. +inline static void XrMatrix4x4f_Transpose(XrMatrix4x4f* result, const XrMatrix4x4f* src) { + result->m[0] = src->m[0]; + result->m[1] = src->m[4]; + result->m[2] = src->m[8]; + result->m[3] = src->m[12]; + + result->m[4] = src->m[1]; + result->m[5] = src->m[5]; + result->m[6] = src->m[9]; + result->m[7] = src->m[13]; + + result->m[8] = src->m[2]; + result->m[9] = src->m[6]; + result->m[10] = src->m[10]; + result->m[11] = src->m[14]; + + result->m[12] = src->m[3]; + result->m[13] = src->m[7]; + result->m[14] = src->m[11]; + result->m[15] = src->m[15]; +} + +// Returns a 3x3 minor of a 4x4 matrix. +inline static float XrMatrix4x4f_Minor(const XrMatrix4x4f* matrix, int r0, int r1, int r2, int c0, int c1, int c2) { + return matrix->m[4 * r0 + c0] * + (matrix->m[4 * r1 + c1] * matrix->m[4 * r2 + c2] - matrix->m[4 * r2 + c1] * matrix->m[4 * r1 + c2]) - + matrix->m[4 * r0 + c1] * + (matrix->m[4 * r1 + c0] * matrix->m[4 * r2 + c2] - matrix->m[4 * r2 + c0] * matrix->m[4 * r1 + c2]) + + matrix->m[4 * r0 + c2] * + (matrix->m[4 * r1 + c0] * matrix->m[4 * r2 + c1] - matrix->m[4 * r2 + c0] * matrix->m[4 * r1 + c1]); +} + +// Calculates the inverse of a 4x4 matrix. +inline static void XrMatrix4x4f_Invert(XrMatrix4x4f* result, const XrMatrix4x4f* src) { + const float rcpDet = + 1.0f / (src->m[0] * XrMatrix4x4f_Minor(src, 1, 2, 3, 1, 2, 3) - src->m[1] * XrMatrix4x4f_Minor(src, 1, 2, 3, 0, 2, 3) + + src->m[2] * XrMatrix4x4f_Minor(src, 1, 2, 3, 0, 1, 3) - src->m[3] * XrMatrix4x4f_Minor(src, 1, 2, 3, 0, 1, 2)); + + result->m[0] = XrMatrix4x4f_Minor(src, 1, 2, 3, 1, 2, 3) * rcpDet; + result->m[1] = -XrMatrix4x4f_Minor(src, 0, 2, 3, 1, 2, 3) * rcpDet; + result->m[2] = XrMatrix4x4f_Minor(src, 0, 1, 3, 1, 2, 3) * rcpDet; + result->m[3] = -XrMatrix4x4f_Minor(src, 0, 1, 2, 1, 2, 3) * rcpDet; + result->m[4] = -XrMatrix4x4f_Minor(src, 1, 2, 3, 0, 2, 3) * rcpDet; + result->m[5] = XrMatrix4x4f_Minor(src, 0, 2, 3, 0, 2, 3) * rcpDet; + result->m[6] = -XrMatrix4x4f_Minor(src, 0, 1, 3, 0, 2, 3) * rcpDet; + result->m[7] = XrMatrix4x4f_Minor(src, 0, 1, 2, 0, 2, 3) * rcpDet; + result->m[8] = XrMatrix4x4f_Minor(src, 1, 2, 3, 0, 1, 3) * rcpDet; + result->m[9] = -XrMatrix4x4f_Minor(src, 0, 2, 3, 0, 1, 3) * rcpDet; + result->m[10] = XrMatrix4x4f_Minor(src, 0, 1, 3, 0, 1, 3) * rcpDet; + result->m[11] = -XrMatrix4x4f_Minor(src, 0, 1, 2, 0, 1, 3) * rcpDet; + result->m[12] = -XrMatrix4x4f_Minor(src, 1, 2, 3, 0, 1, 2) * rcpDet; + result->m[13] = XrMatrix4x4f_Minor(src, 0, 2, 3, 0, 1, 2) * rcpDet; + result->m[14] = -XrMatrix4x4f_Minor(src, 0, 1, 3, 0, 1, 2) * rcpDet; + result->m[15] = XrMatrix4x4f_Minor(src, 0, 1, 2, 0, 1, 2) * rcpDet; +} + +// Calculates the inverse of a rigid body transform. +inline static void XrMatrix4x4f_InvertRigidBody(XrMatrix4x4f* result, const XrMatrix4x4f* src) { + result->m[0] = src->m[0]; + result->m[1] = src->m[4]; + result->m[2] = src->m[8]; + result->m[3] = 0.0f; + result->m[4] = src->m[1]; + result->m[5] = src->m[5]; + result->m[6] = src->m[9]; + result->m[7] = 0.0f; + result->m[8] = src->m[2]; + result->m[9] = src->m[6]; + result->m[10] = src->m[10]; + result->m[11] = 0.0f; + result->m[12] = -(src->m[0] * src->m[12] + src->m[1] * src->m[13] + src->m[2] * src->m[14]); + result->m[13] = -(src->m[4] * src->m[12] + src->m[5] * src->m[13] + src->m[6] * src->m[14]); + result->m[14] = -(src->m[8] * src->m[12] + src->m[9] * src->m[13] + src->m[10] * src->m[14]); + result->m[15] = 1.0f; +} + +// Creates an identity matrix. +inline static void XrMatrix4x4f_CreateIdentity(XrMatrix4x4f* result) { + result->m[0] = 1.0f; + result->m[1] = 0.0f; + result->m[2] = 0.0f; + result->m[3] = 0.0f; + result->m[4] = 0.0f; + result->m[5] = 1.0f; + result->m[6] = 0.0f; + result->m[7] = 0.0f; + result->m[8] = 0.0f; + result->m[9] = 0.0f; + result->m[10] = 1.0f; + result->m[11] = 0.0f; + result->m[12] = 0.0f; + result->m[13] = 0.0f; + result->m[14] = 0.0f; + result->m[15] = 1.0f; +} + +// Creates a translation matrix. +inline static void XrMatrix4x4f_CreateTranslation(XrMatrix4x4f* result, const float x, const float y, const float z) { + result->m[0] = 1.0f; + result->m[1] = 0.0f; + result->m[2] = 0.0f; + result->m[3] = 0.0f; + result->m[4] = 0.0f; + result->m[5] = 1.0f; + result->m[6] = 0.0f; + result->m[7] = 0.0f; + result->m[8] = 0.0f; + result->m[9] = 0.0f; + result->m[10] = 1.0f; + result->m[11] = 0.0f; + result->m[12] = x; + result->m[13] = y; + result->m[14] = z; + result->m[15] = 1.0f; +} + +// Creates a rotation matrix. +// If -Z=forward, +Y=up, +X=right, then radiansX=pitch, radiansY=yaw, radiansZ=roll. +inline static void XrMatrix4x4f_CreateRotationRadians(XrMatrix4x4f* result, const float radiansX, const float radiansY, + const float radiansZ) { + const float sinX = sinf(radiansX); + const float cosX = cosf(radiansX); + const XrMatrix4x4f rotationX = {{1, 0, 0, 0, 0, cosX, sinX, 0, 0, -sinX, cosX, 0, 0, 0, 0, 1}}; + const float sinY = sinf(radiansY); + const float cosY = cosf(radiansY); + const XrMatrix4x4f rotationY = {{cosY, 0, -sinY, 0, 0, 1, 0, 0, sinY, 0, cosY, 0, 0, 0, 0, 1}}; + const float sinZ = sinf(radiansZ); + const float cosZ = cosf(radiansZ); + const XrMatrix4x4f rotationZ = {{cosZ, sinZ, 0, 0, -sinZ, cosZ, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1}}; + XrMatrix4x4f rotationXY; + XrMatrix4x4f_Multiply(&rotationXY, &rotationY, &rotationX); + XrMatrix4x4f_Multiply(result, &rotationZ, &rotationXY); +} + +// Creates a rotation matrix. +// If -Z=forward, +Y=up, +X=right, then degreesX=pitch, degreesY=yaw, degreesZ=roll. +inline static void XrMatrix4x4f_CreateRotation(XrMatrix4x4f* result, const float degreesX, const float degreesY, + const float degreesZ) { + XrMatrix4x4f_CreateRotationRadians(result, degreesX * (MATH_PI / 180.0f), degreesY * (MATH_PI / 180.0f), + degreesZ * (MATH_PI / 180.0f)); +} + +// Creates a scale matrix. +inline static void XrMatrix4x4f_CreateScale(XrMatrix4x4f* result, const float x, const float y, const float z) { + result->m[0] = x; + result->m[1] = 0.0f; + result->m[2] = 0.0f; + result->m[3] = 0.0f; + result->m[4] = 0.0f; + result->m[5] = y; + result->m[6] = 0.0f; + result->m[7] = 0.0f; + result->m[8] = 0.0f; + result->m[9] = 0.0f; + result->m[10] = z; + result->m[11] = 0.0f; + result->m[12] = 0.0f; + result->m[13] = 0.0f; + result->m[14] = 0.0f; + result->m[15] = 1.0f; +} + +// Creates a matrix from a quaternion. +inline static void XrMatrix4x4f_CreateFromQuaternion(XrMatrix4x4f* result, const XrQuaternionf* quat) { + const float x2 = quat->x + quat->x; + const float y2 = quat->y + quat->y; + const float z2 = quat->z + quat->z; + + const float xx2 = quat->x * x2; + const float yy2 = quat->y * y2; + const float zz2 = quat->z * z2; + + const float yz2 = quat->y * z2; + const float wx2 = quat->w * x2; + const float xy2 = quat->x * y2; + const float wz2 = quat->w * z2; + const float xz2 = quat->x * z2; + const float wy2 = quat->w * y2; + + result->m[0] = 1.0f - yy2 - zz2; + result->m[1] = xy2 + wz2; + result->m[2] = xz2 - wy2; + result->m[3] = 0.0f; + + result->m[4] = xy2 - wz2; + result->m[5] = 1.0f - xx2 - zz2; + result->m[6] = yz2 + wx2; + result->m[7] = 0.0f; + + result->m[8] = xz2 + wy2; + result->m[9] = yz2 - wx2; + result->m[10] = 1.0f - xx2 - yy2; + result->m[11] = 0.0f; + + result->m[12] = 0.0f; + result->m[13] = 0.0f; + result->m[14] = 0.0f; + result->m[15] = 1.0f; +} + +// Creates a combined translation(rotation(scale(object))) matrix. +inline static void XrMatrix4x4f_CreateTranslationRotationScale(XrMatrix4x4f* result, const XrVector3f* translation, + const XrQuaternionf* rotation, const XrVector3f* scale) { + XrMatrix4x4f scaleMatrix; + XrMatrix4x4f_CreateScale(&scaleMatrix, scale->x, scale->y, scale->z); + + XrMatrix4x4f rotationMatrix; + XrMatrix4x4f_CreateFromQuaternion(&rotationMatrix, rotation); + + XrMatrix4x4f translationMatrix; + XrMatrix4x4f_CreateTranslation(&translationMatrix, translation->x, translation->y, translation->z); + + XrMatrix4x4f combinedMatrix; + XrMatrix4x4f_Multiply(&combinedMatrix, &rotationMatrix, &scaleMatrix); + XrMatrix4x4f_Multiply(result, &translationMatrix, &combinedMatrix); +} + +inline static void XrMatrix4x4f_CreateFromRigidTransform(XrMatrix4x4f* result, const XrPosef* s) { + const XrVector3f identityScale = {1.0f, 1.0f, 1.0f}; + XrMatrix4x4f_CreateTranslationRotationScale(result, &s->position, &s->orientation, &identityScale); +} + +// Creates a projection matrix based on the specified dimensions. +// The projection matrix transforms -Z=forward, +Y=up, +X=right to the appropriate clip space for the graphics API. +// The far plane is placed at infinity if farZ <= nearZ. +// An infinite projection matrix is preferred for rasterization because, except for +// things *right* up against the near plane, it always provides better precision: +// "Tightening the Precision of Perspective Rendering" +// Paul Upchurch, Mathieu Desbrun +// Journal of Graphics Tools, Volume 16, Issue 1, 2012 +inline static void XrMatrix4x4f_CreateProjection(XrMatrix4x4f* result, GraphicsAPI graphicsApi, const float tanAngleLeft, + const float tanAngleRight, const float tanAngleUp, float const tanAngleDown, + const float nearZ, const float farZ) { + const float tanAngleWidth = tanAngleRight - tanAngleLeft; + + // Set to tanAngleDown - tanAngleUp for a clip space with positive Y down (Vulkan). + // Set to tanAngleUp - tanAngleDown for a clip space with positive Y up (OpenGL / D3D / Metal). + const float tanAngleHeight = graphicsApi == GRAPHICS_VULKAN ? (tanAngleDown - tanAngleUp) : (tanAngleUp - tanAngleDown); + + // Set to nearZ for a [-1,1] Z clip space (OpenGL / OpenGL ES). + // Set to zero for a [0,1] Z clip space (Vulkan / D3D / Metal). + const float offsetZ = (graphicsApi == GRAPHICS_OPENGL || graphicsApi == GRAPHICS_OPENGL_ES) ? nearZ : 0; + + if (farZ <= nearZ) { + // place the far plane at infinity + result->m[0] = 2.0f / tanAngleWidth; + result->m[4] = 0.0f; + result->m[8] = (tanAngleRight + tanAngleLeft) / tanAngleWidth; + result->m[12] = 0.0f; + + result->m[1] = 0.0f; + result->m[5] = 2.0f / tanAngleHeight; + result->m[9] = (tanAngleUp + tanAngleDown) / tanAngleHeight; + result->m[13] = 0.0f; + + result->m[2] = 0.0f; + result->m[6] = 0.0f; + result->m[10] = -1.0f; + result->m[14] = -(nearZ + offsetZ); + + result->m[3] = 0.0f; + result->m[7] = 0.0f; + result->m[11] = -1.0f; + result->m[15] = 0.0f; + } else { + // normal projection + result->m[0] = 2.0f / tanAngleWidth; + result->m[4] = 0.0f; + result->m[8] = (tanAngleRight + tanAngleLeft) / tanAngleWidth; + result->m[12] = 0.0f; + + result->m[1] = 0.0f; + result->m[5] = 2.0f / tanAngleHeight; + result->m[9] = (tanAngleUp + tanAngleDown) / tanAngleHeight; + result->m[13] = 0.0f; + + result->m[2] = 0.0f; + result->m[6] = 0.0f; + result->m[10] = -(farZ + offsetZ) / (farZ - nearZ); + result->m[14] = -(farZ * (nearZ + offsetZ)) / (farZ - nearZ); + + result->m[3] = 0.0f; + result->m[7] = 0.0f; + result->m[11] = -1.0f; + result->m[15] = 0.0f; + } +} + +// Creates a projection matrix based on the specified FOV. +inline static void XrMatrix4x4f_CreateProjectionFov(XrMatrix4x4f* result, GraphicsAPI graphicsApi, const XrFovf fov, + const float nearZ, const float farZ) { + const float tanLeft = tanf(fov.angleLeft); + const float tanRight = tanf(fov.angleRight); + + const float tanDown = tanf(fov.angleDown); + const float tanUp = tanf(fov.angleUp); + + XrMatrix4x4f_CreateProjection(result, graphicsApi, tanLeft, tanRight, tanUp, tanDown, nearZ, farZ); +} + +// Creates a matrix that transforms the -1 to 1 cube to cover the given 'mins' and 'maxs' transformed with the given 'matrix'. +inline static void XrMatrix4x4f_CreateOffsetScaleForBounds(XrMatrix4x4f* result, const XrMatrix4x4f* matrix, const XrVector3f* mins, + const XrVector3f* maxs) { + const XrVector3f offset = {(maxs->x + mins->x) * 0.5f, (maxs->y + mins->y) * 0.5f, (maxs->z + mins->z) * 0.5f}; + const XrVector3f scale = {(maxs->x - mins->x) * 0.5f, (maxs->y - mins->y) * 0.5f, (maxs->z - mins->z) * 0.5f}; + + result->m[0] = matrix->m[0] * scale.x; + result->m[1] = matrix->m[1] * scale.x; + result->m[2] = matrix->m[2] * scale.x; + result->m[3] = matrix->m[3] * scale.x; + + result->m[4] = matrix->m[4] * scale.y; + result->m[5] = matrix->m[5] * scale.y; + result->m[6] = matrix->m[6] * scale.y; + result->m[7] = matrix->m[7] * scale.y; + + result->m[8] = matrix->m[8] * scale.z; + result->m[9] = matrix->m[9] * scale.z; + result->m[10] = matrix->m[10] * scale.z; + result->m[11] = matrix->m[11] * scale.z; + + result->m[12] = matrix->m[12] + matrix->m[0] * offset.x + matrix->m[4] * offset.y + matrix->m[8] * offset.z; + result->m[13] = matrix->m[13] + matrix->m[1] * offset.x + matrix->m[5] * offset.y + matrix->m[9] * offset.z; + result->m[14] = matrix->m[14] + matrix->m[2] * offset.x + matrix->m[6] * offset.y + matrix->m[10] * offset.z; + result->m[15] = matrix->m[15] + matrix->m[3] * offset.x + matrix->m[7] * offset.y + matrix->m[11] * offset.z; +} + +// Returns true if the given matrix is affine. +inline static bool XrMatrix4x4f_IsAffine(const XrMatrix4x4f* matrix, const float epsilon) { + return fabsf(matrix->m[3]) <= epsilon && fabsf(matrix->m[7]) <= epsilon && fabsf(matrix->m[11]) <= epsilon && + fabsf(matrix->m[15] - 1.0f) <= epsilon; +} + +// Returns true if the given matrix is orthogonal. +inline static bool XrMatrix4x4f_IsOrthogonal(const XrMatrix4x4f* matrix, const float epsilon) { + for (int i = 0; i < 3; i++) { + for (int j = 0; j < 3; j++) { + if (i != j) { + if (fabsf(matrix->m[4 * i + 0] * matrix->m[4 * j + 0] + matrix->m[4 * i + 1] * matrix->m[4 * j + 1] + + matrix->m[4 * i + 2] * matrix->m[4 * j + 2]) > epsilon) { + return false; + } + if (fabsf(matrix->m[4 * 0 + i] * matrix->m[4 * 0 + j] + matrix->m[4 * 1 + i] * matrix->m[4 * 1 + j] + + matrix->m[4 * 2 + i] * matrix->m[4 * 2 + j]) > epsilon) { + return false; + } + } + } + } + return true; +} + +// Returns true if the given matrix is orthonormal. +inline static bool XrMatrix4x4f_IsOrthonormal(const XrMatrix4x4f* matrix, const float epsilon) { + for (int i = 0; i < 3; i++) { + for (int j = 0; j < 3; j++) { + const float kd = (i == j) ? 1.0f : 0.0f; // Kronecker delta + if (fabsf(kd - (matrix->m[4 * i + 0] * matrix->m[4 * j + 0] + matrix->m[4 * i + 1] * matrix->m[4 * j + 1] + + matrix->m[4 * i + 2] * matrix->m[4 * j + 2])) > epsilon) { + return false; + } + if (fabsf(kd - (matrix->m[4 * 0 + i] * matrix->m[4 * 0 + j] + matrix->m[4 * 1 + i] * matrix->m[4 * 1 + j] + + matrix->m[4 * 2 + i] * matrix->m[4 * 2 + j])) > epsilon) { + return false; + } + } + } + return true; +} + +// Returns true if the given matrix is a rigid body transform. +inline static bool XrMatrix4x4f_IsRigidBody(const XrMatrix4x4f* matrix, const float epsilon) { + return XrMatrix4x4f_IsAffine(matrix, epsilon) && XrMatrix4x4f_IsOrthonormal(matrix, epsilon); +} + +// Get the translation from a combined translation(rotation(scale(object))) matrix. +inline static void XrMatrix4x4f_GetTranslation(XrVector3f* result, const XrMatrix4x4f* src) { + assert(XrMatrix4x4f_IsAffine(src, 1e-4f)); + assert(XrMatrix4x4f_IsOrthogonal(src, 1e-4f)); + + result->x = src->m[12]; + result->y = src->m[13]; + result->z = src->m[14]; +} + +// Get the rotation from a combined translation(rotation(scale(object))) matrix. +inline static void XrMatrix4x4f_GetRotation(XrQuaternionf* result, const XrMatrix4x4f* src) { + assert(XrMatrix4x4f_IsAffine(src, 1e-4f)); + assert(XrMatrix4x4f_IsOrthogonal(src, 1e-4f)); + + const float rcpScaleX = XrRcpSqrt(src->m[0] * src->m[0] + src->m[1] * src->m[1] + src->m[2] * src->m[2]); + const float rcpScaleY = XrRcpSqrt(src->m[4] * src->m[4] + src->m[5] * src->m[5] + src->m[6] * src->m[6]); + const float rcpScaleZ = XrRcpSqrt(src->m[8] * src->m[8] + src->m[9] * src->m[9] + src->m[10] * src->m[10]); + const float m[9] = {src->m[0] * rcpScaleX, src->m[1] * rcpScaleX, src->m[2] * rcpScaleX, + src->m[4] * rcpScaleY, src->m[5] * rcpScaleY, src->m[6] * rcpScaleY, + src->m[8] * rcpScaleZ, src->m[9] * rcpScaleZ, src->m[10] * rcpScaleZ}; + if (m[0 * 3 + 0] + m[1 * 3 + 1] + m[2 * 3 + 2] > 0.0f) { + float t = +m[0 * 3 + 0] + m[1 * 3 + 1] + m[2 * 3 + 2] + 1.0f; + float s = XrRcpSqrt(t) * 0.5f; + result->w = s * t; + result->z = (m[0 * 3 + 1] - m[1 * 3 + 0]) * s; + result->y = (m[2 * 3 + 0] - m[0 * 3 + 2]) * s; + result->x = (m[1 * 3 + 2] - m[2 * 3 + 1]) * s; + } else if (m[0 * 3 + 0] > m[1 * 3 + 1] && m[0 * 3 + 0] > m[2 * 3 + 2]) { + float t = +m[0 * 3 + 0] - m[1 * 3 + 1] - m[2 * 3 + 2] + 1.0f; + float s = XrRcpSqrt(t) * 0.5f; + result->x = s * t; + result->y = (m[0 * 3 + 1] + m[1 * 3 + 0]) * s; + result->z = (m[2 * 3 + 0] + m[0 * 3 + 2]) * s; + result->w = (m[1 * 3 + 2] - m[2 * 3 + 1]) * s; + } else if (m[1 * 3 + 1] > m[2 * 3 + 2]) { + float t = -m[0 * 3 + 0] + m[1 * 3 + 1] - m[2 * 3 + 2] + 1.0f; + float s = XrRcpSqrt(t) * 0.5f; + result->y = s * t; + result->x = (m[0 * 3 + 1] + m[1 * 3 + 0]) * s; + result->w = (m[2 * 3 + 0] - m[0 * 3 + 2]) * s; + result->z = (m[1 * 3 + 2] + m[2 * 3 + 1]) * s; + } else { + float t = -m[0 * 3 + 0] - m[1 * 3 + 1] + m[2 * 3 + 2] + 1.0f; + float s = XrRcpSqrt(t) * 0.5f; + result->z = s * t; + result->w = (m[0 * 3 + 1] - m[1 * 3 + 0]) * s; + result->x = (m[2 * 3 + 0] + m[0 * 3 + 2]) * s; + result->y = (m[1 * 3 + 2] + m[2 * 3 + 1]) * s; + } +} + +// Get the scale from a combined translation(rotation(scale(object))) matrix. +inline static void XrMatrix4x4f_GetScale(XrVector3f* result, const XrMatrix4x4f* src) { + assert(XrMatrix4x4f_IsAffine(src, 1e-4f)); + assert(XrMatrix4x4f_IsOrthogonal(src, 1e-4f)); + + result->x = sqrtf(src->m[0] * src->m[0] + src->m[1] * src->m[1] + src->m[2] * src->m[2]); + result->y = sqrtf(src->m[4] * src->m[4] + src->m[5] * src->m[5] + src->m[6] * src->m[6]); + result->z = sqrtf(src->m[8] * src->m[8] + src->m[9] * src->m[9] + src->m[10] * src->m[10]); +} + +// Transforms a 3D vector. +inline static void XrMatrix4x4f_TransformVector3f(XrVector3f* result, const XrMatrix4x4f* m, const XrVector3f* v) { + const float w = m->m[3] * v->x + m->m[7] * v->y + m->m[11] * v->z + m->m[15]; + const float rcpW = 1.0f / w; + result->x = (m->m[0] * v->x + m->m[4] * v->y + m->m[8] * v->z + m->m[12]) * rcpW; + result->y = (m->m[1] * v->x + m->m[5] * v->y + m->m[9] * v->z + m->m[13]) * rcpW; + result->z = (m->m[2] * v->x + m->m[6] * v->y + m->m[10] * v->z + m->m[14]) * rcpW; +} + +// Transforms a 4D vector. +inline static void XrMatrix4x4f_TransformVector4f(XrVector4f* result, const XrMatrix4x4f* m, const XrVector4f* v) { + result->x = m->m[0] * v->x + m->m[4] * v->y + m->m[8] * v->z + m->m[12] * v->w; + result->y = m->m[1] * v->x + m->m[5] * v->y + m->m[9] * v->z + m->m[13] * v->w; + result->z = m->m[2] * v->x + m->m[6] * v->y + m->m[10] * v->z + m->m[14] * v->w; + result->w = m->m[3] * v->x + m->m[7] * v->y + m->m[11] * v->z + m->m[15] * v->w; +} + +// Transforms the 'mins' and 'maxs' bounds with the given 'matrix'. +inline static void XrMatrix4x4f_TransformBounds(XrVector3f* resultMins, XrVector3f* resultMaxs, const XrMatrix4x4f* matrix, + const XrVector3f* mins, const XrVector3f* maxs) { + assert(XrMatrix4x4f_IsAffine(matrix, 1e-4f)); + + const XrVector3f center = {(mins->x + maxs->x) * 0.5f, (mins->y + maxs->y) * 0.5f, (mins->z + maxs->z) * 0.5f}; + const XrVector3f extents = {maxs->x - center.x, maxs->y - center.y, maxs->z - center.z}; + const XrVector3f newCenter = {matrix->m[0] * center.x + matrix->m[4] * center.y + matrix->m[8] * center.z + matrix->m[12], + matrix->m[1] * center.x + matrix->m[5] * center.y + matrix->m[9] * center.z + matrix->m[13], + matrix->m[2] * center.x + matrix->m[6] * center.y + matrix->m[10] * center.z + matrix->m[14]}; + const XrVector3f newExtents = { + fabsf(extents.x * matrix->m[0]) + fabsf(extents.y * matrix->m[4]) + fabsf(extents.z * matrix->m[8]), + fabsf(extents.x * matrix->m[1]) + fabsf(extents.y * matrix->m[5]) + fabsf(extents.z * matrix->m[9]), + fabsf(extents.x * matrix->m[2]) + fabsf(extents.y * matrix->m[6]) + fabsf(extents.z * matrix->m[10])}; + XrVector3f_Sub(resultMins, &newCenter, &newExtents); + XrVector3f_Add(resultMaxs, &newCenter, &newExtents); +} + +// Returns true if the 'mins' and 'maxs' bounds is completely off to one side of the projection matrix. +inline static bool XrMatrix4x4f_CullBounds(const XrMatrix4x4f* mvp, const XrVector3f* mins, const XrVector3f* maxs) { + if (maxs->x <= mins->x && maxs->y <= mins->y && maxs->z <= mins->z) { + return false; + } + + XrVector4f c[8]; + for (int i = 0; i < 8; i++) { + const XrVector4f corner = {(i & 1) != 0 ? maxs->x : mins->x, (i & 2) != 0 ? maxs->y : mins->y, + (i & 4) != 0 ? maxs->z : mins->z, 1.0f}; + XrMatrix4x4f_TransformVector4f(&c[i], mvp, &corner); + } + + int i; + for (i = 0; i < 8; i++) { + if (c[i].x > -c[i].w) { + break; + } + } + if (i == 8) { + return true; + } + for (i = 0; i < 8; i++) { + if (c[i].x < c[i].w) { + break; + } + } + if (i == 8) { + return true; + } + + for (i = 0; i < 8; i++) { + if (c[i].y > -c[i].w) { + break; + } + } + if (i == 8) { + return true; + } + for (i = 0; i < 8; i++) { + if (c[i].y < c[i].w) { + break; + } + } + if (i == 8) { + return true; + } + for (i = 0; i < 8; i++) { + if (c[i].z > -c[i].w) { + break; + } + } + if (i == 8) { + return true; + } + for (i = 0; i < 8; i++) { + if (c[i].z < c[i].w) { + break; + } + } + return i == 8; +} + +#endif // XR_LINEAR_H_ diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/common_config.h.in b/shadps4-arm64-main/externals/openxr-sdk/src/common_config.h.in new file mode 100644 index 0000000..d11064d --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/common_config.h.in @@ -0,0 +1,26 @@ +// Copyright (c) 2017-2026 The Khronos Group Inc. +// Copyright (c) 2017 Valve Corporation +// Copyright (c) 2017 LunarG, Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT + + +// If this file has a .h.in extension, it's the input for CMake to generate a header from. +// If it has a .h extension, THIS IS A GENERATED FILE - DO NOT EDIT + +// To include the generated version of this file, make sure OPENXR_HAVE_COMMON_CONFIG is defined. +// The provided CMake build system does this automatically. +// +// If you can't provide the .h version of this file (because you're not using the +// provided CMake build system and not providing it yourself), you need to do the following: +// +// - On non-Windows, for security purposes, define one of +// `HAVE_SECURE_GETENV` or `HAVE___SECURE_GETENV` depending on which +// of secure_getenv or __secure_getenv are present, respectively + + +// If defined, secure_getenv is available +#cmakedefine HAVE_SECURE_GETENV + +// If defined, __secure_getenv is available +#cmakedefine HAVE___SECURE_GETENV diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/ObjectWrapperBase.h b/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/ObjectWrapperBase.h new file mode 100644 index 0000000..5aff766 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/ObjectWrapperBase.h @@ -0,0 +1,337 @@ +// Copyright 2020-2021, Collabora, Ltd. +// SPDX-License-Identifier: BSL-1.0 +// Author: Rylie Pavlik <rylie.pavlik@collabora.com> + +#pragma once +#include <assert.h> +#include <jni.h> +#include <jnipp.h> + +namespace wrap { + +/*! + * Base class for types wrapping Java types. + * + * Derived types are encouraged to have a nested `struct Meta`, inheriting + * publicly from MetaBaseDroppable or MetaBase, with a singleton accessor named + * `data()`, and a private constructor (implemented in a .cpp file, not the + * header) that populates jni::method_t, jni::field_t, etc. members for each + * method, etc. of interest. + */ +class ObjectWrapperBase { + public: + /*! + * Default constructor. + */ + ObjectWrapperBase() = default; + + /*! + * Construct from a jni::Object. + */ + explicit ObjectWrapperBase(jni::Object obj) : obj_(std::move(obj)) {} + + /*! + * Construct from a nullptr. + */ + explicit ObjectWrapperBase(std::nullptr_t const &) : obj_() {} + + /*! + * Evaluate if this is non-null + */ + explicit operator bool() const noexcept { return !obj_.isNull(); } + + /*! + * Is this object null? + */ + bool isNull() const noexcept { return obj_.isNull(); } + + /*! + * Get the wrapped jni::Object + */ + jni::Object &object() noexcept { return obj_; } + + /*! + * Get the wrapped jni::Object (const overload) + */ + jni::Object const &object() const noexcept { return obj_; } + + private: + jni::Object obj_; +}; + +/*! + * Equality comparison for a wrapped Java object. + */ +static inline bool operator==(ObjectWrapperBase const &lhs, + ObjectWrapperBase const &rhs) noexcept { + return lhs.object() == rhs.object(); +} + +/*! + * Inequality comparison for a wrapped Java object. + */ +static inline bool operator!=(ObjectWrapperBase const &lhs, + ObjectWrapperBase const &rhs) noexcept { + return lhs.object() != rhs.object(); +} + +/*! + * Equality comparison between a wrapped Java object and @p nullptr. + */ +static inline bool operator==(ObjectWrapperBase const &obj, + std::nullptr_t) noexcept { + return obj.isNull(); +} + +/*! + * Equality comparison between a wrapped Java object and @p nullptr. + */ +static inline bool operator==(std::nullptr_t, + ObjectWrapperBase const &obj) noexcept { + return obj.isNull(); +} + +/*! + * Inequality comparison between a wrapped Java object and @p nullptr. + */ +static inline bool operator!=(ObjectWrapperBase const &obj, + std::nullptr_t) noexcept { + return !(obj == nullptr); +} + +/*! + * Inequality comparison between a wrapped Java object and @p nullptr. + */ +static inline bool operator!=(std::nullptr_t, + ObjectWrapperBase const &obj) noexcept { + return !(obj == nullptr); +} + +/*! + * Base class for Meta structs where you want the reference to the Class object + * to persist (indefinitely). + * + * Mostly for classes that would stick around anyway (e.g. + * @p java.lang.ClassLoader ) where many operations are on static + * methods/fields. Use of a non-static method or field does not require such a + * reference, use MetaBaseDroppable in those cases. + */ +class MetaBase { + public: + /*! + * Gets a reference to the class object. + * + * Unlike MetaBaseDroppable, here we know that the class object ref is + * alive. + */ + jni::Class const &clazz() const noexcept { return clazz_; } + /*! + * Gets a reference to the class object. + * + * Provided here for parallel API to MetaBaseDroppable, despite being + * synonymous with clazz() here. + */ + jni::Class const &classRef() const noexcept { return clazz_; } + + /*! + * Get the class name, with namespaces delimited by `/`. + */ + const char *className() const noexcept { return classname_; } + + protected: + /*! + * Construct. + * + * @param classname The class name, fully qualified, with namespaces + * delimited by `/`. + * @param clazz The jclass object for the class in question, if known. + */ + explicit MetaBase(const char *classname, jni::jclass clazz = nullptr) + : classname_(classname), clazz_() { + if (clazz != nullptr) { + // The 0 makes it a global ref. + clazz_ = jni::Class{clazz, 0}; + } else { + clazz_ = jni::Class{classname}; + } + } + + private: + const char *classname_; + jni::Class clazz_; +}; + +/*! + * Base class for Meta structs where you don't need the reference to the Class + * object to persist. (This is most uses.) + */ +class MetaBaseDroppable { + public: + /*! + * Gets the class object. + * + * Works regardless of whether dropClassRef() has been called - it's just + * slower if it has. + */ + jni::Class clazz() const { + if (clazz_.isNull()) { + return {classname_}; + } + return clazz_; + } + + /*! + * Get the class name, with namespaces delimited by `/`. + */ + const char *className() const noexcept { return classname_; } + + /*! + * May be called in/after the derived constructor, to drop the reference to + * the class object if it's no longer needed. + */ + void dropClassRef() { clazz_ = jni::Class{}; } + + protected: + /*! + * Construct. + * + * Once you are done constructing your derived struct, you may call + * dropClassRef() and still safely use non-static method and field IDs + * retrieved. + * + * @param classname The class name, fully qualified, with namespaces + * delimited by `/`. + * @param clazz The jclass object for the class in question, if known. + */ + explicit MetaBaseDroppable(const char *classname, + jni::jclass clazz = nullptr) + : classname_(classname), clazz_() { + if (clazz != nullptr) { + // The 0 makes it a global ref. + clazz_ = jni::Class{clazz, 0}; + } else { + clazz_ = jni::Class{classname}; + } + } + + /*! + * Gets a reference to the class object, but is non-null only if it's still + * cached. + * + * Only for used in derived constructors/initializers, where you know you + * haven't dropped this yet. + */ + jni::Class const &classRef() const { return clazz_; } + + private: + const char *classname_; + jni::Class clazz_; +}; + +/*! + * Implementation namespace for these JNI wrappers. + * + * They can be ignored if you aren't adding/extending wrappers. + */ +namespace impl { +/*! + * Type-aware wrapper for a field ID. + * + * This is a smarter alternative to just using jni::field_t since it avoids + * having to repeat the type in the accessor, without using any more storage. + * + * @see StaticFieldId for the equivalent for static fields. + * @see WrappedFieldId for the equivalent for structures that we wrap. + */ +template <typename T> struct FieldId { + public: + FieldId(jni::Class const &clazz, const char *name) + : id(clazz.getField<T>(name)) {} + + const jni::field_t id; +}; + +/*! + * Get the value of field @p field in Java object @p obj. + * + * This is found by argument-dependent lookup and can be used unqualified. + * + * @relates FieldId + */ +template <typename T> +static inline T get(FieldId<T> const &field, jni::Object const &obj) { + assert(!obj.isNull()); + return obj.get<T>(field.id); +} +/*! + * Type-aware wrapper for a static field ID. + * + * This is a smarter alternative to just using jni::field_t since it avoids + * having to repeat the type in the accessor, without using any more storage. + * + * @see FieldId + */ +template <typename T> struct StaticFieldId { + public: + StaticFieldId(jni::Class const &clazz, const char *name) + : id(clazz.getStaticField<T>(name)) {} + + const jni::field_t id; +}; + +/*! + * Get the value of static field @p field in Java type @p clazz. + * + * This is found by argument-dependent lookup and can be used unqualified. + * + * @relates FieldId + */ +template <typename T> +static inline T get(StaticFieldId<T> const &field, jni::Class const &clazz) { + assert(!clazz.isNull()); + return clazz.get<T>(field.id); +} + +/*! + * Type-aware wrapper for a field ID of a wrapped structure type. + * + * This is a smarter alternative to just using jni::field_t since it avoids + * having to repeat the type in the accessor, without using any more storage. + * + * Requires that the structure wrapper provides + * `static constexpr const char *getTypeName() noexcept;` + * + * @see FieldId + */ +template <typename T> struct WrappedFieldId { + public: + WrappedFieldId(jni::Class const &clazz, const char *name) + : id(lookupField(clazz, name)) {} + + const jni::field_t id; + + private: + /*! + * Helper for field ID lookup, mostly to avoid calling c_str() on a string + * temporary. + */ + static jni::field_t lookupField(jni::Class const &clazz, const char *name) { + std::string fullType = std::string("L") + T::getTypeName() + ";"; + return clazz.getField(name, fullType.c_str()); + } +}; + +/*! + * Get the value of field @p field in Java object @p obj. + * + * This is found by argument-dependent lookup and can be used unqualified. + * + * @relates WrappedFieldId + */ +template <typename T> +static inline T get(WrappedFieldId<T> const &field, jni::Object const &obj) { + assert(!obj.isNull()); + return T{obj.get<jni::Object>(field.id)}; +} +} // namespace impl +} // namespace wrap diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.content.cpp b/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.content.cpp new file mode 100644 index 0000000..5926a72 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.content.cpp @@ -0,0 +1,52 @@ +// Copyright 2020-2021, Collabora, Ltd. +// SPDX-License-Identifier: BSL-1.0 +// Author: Rylie Pavlik <rylie.pavlik@collabora.com> + +#include "android.content.h" + +namespace wrap { +namespace android::content { +Context::Meta::Meta(bool deferDrop) + : MetaBaseDroppable(Context::getTypeName()), + getContentResolver(classRef().getMethod( + "getContentResolver", "()Landroid/content/ContentResolver;")) { + if (!deferDrop) { + MetaBaseDroppable::dropClassRef(); + } +} +ContentUris::Meta::Meta(bool deferDrop) + : MetaBaseDroppable(ContentUris::getTypeName()), + appendId(classRef().getStaticMethod( + "appendId", + "(Landroid/net/Uri$Builder;J)Landroid/net/Uri$Builder;")) { + if (!deferDrop) { + MetaBaseDroppable::dropClassRef(); + } +} +ComponentName::Meta::Meta() + : MetaBase(ComponentName::getTypeName()), + init(classRef().getMethod("<init>", + "(Ljava/lang/String;Ljava/lang/String;)V")), + init1(classRef().getMethod( + "<init>", "(Landroid/content/Context;Ljava/lang/String;)V")), + init2(classRef().getMethod( + "<init>", "(Landroid/content/Context;Ljava/lang/Class;)V")), + init3(classRef().getMethod("<init>", "(Landroid/os/Parcel;)V")) {} +ContentResolver::Meta::Meta() + : MetaBaseDroppable(ContentResolver::getTypeName()), + query(classRef().getMethod( + "query", + "(Landroid/net/Uri;[Ljava/lang/String;Ljava/lang/String;[Ljava/lang/" + "String;Ljava/lang/String;)Landroid/database/Cursor;")), + query1(classRef().getMethod( + "query", "(Landroid/net/Uri;[Ljava/lang/String;Ljava/lang/" + "String;[Ljava/lang/String;Ljava/lang/String;Landroid/os/" + "CancellationSignal;)Landroid/database/Cursor;")), + query2(classRef().getMethod( + "query", + "(Landroid/net/Uri;[Ljava/lang/String;Landroid/os/Bundle;Landroid/os/" + "CancellationSignal;)Landroid/database/Cursor;")) { + MetaBaseDroppable::dropClassRef(); +} +} // namespace android::content +} // namespace wrap diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.content.h b/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.content.h new file mode 100644 index 0000000..ba685e5 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.content.h @@ -0,0 +1,296 @@ +// Copyright 2020-2021, Collabora, Ltd. +// SPDX-License-Identifier: BSL-1.0 +// Author: Rylie Pavlik <rylie.pavlik@collabora.com> + +#pragma once + +#include "ObjectWrapperBase.h" + +namespace wrap { +namespace android::content { +class ComponentName; +class ContentResolver; +class Context; +} // namespace android::content + +namespace android::database { +class Cursor; +} // namespace android::database + +namespace android::net { +class Uri; +class Uri_Builder; +} // namespace android::net + +} // namespace wrap + +namespace wrap { +namespace android::content { +/*! + * Wrapper for android.content.Context objects. + */ +class Context : public ObjectWrapperBase { + public: + using ObjectWrapperBase::ObjectWrapperBase; + static constexpr const char *getTypeName() noexcept { + return "android/content/Context"; + } + + /*! + * Wrapper for the getContentResolver method + * + * Java prototype: + * `public abstract android.content.ContentResolver getContentResolver();` + * + * JNI signature: ()Landroid/content/ContentResolver; + * + */ + ContentResolver getContentResolver() const; + + /*! + * Class metadata + */ + struct Meta : public MetaBaseDroppable { + jni::method_t getContentResolver; + + /*! + * Singleton accessor + */ + static Meta &data(bool deferDrop = false) { + static Meta instance{deferDrop}; + return instance; + } + + private: + explicit Meta(bool deferDrop); + }; +}; + +/*! + * Wrapper for android.content.ContentUris objects. + */ +class ContentUris : public ObjectWrapperBase { + public: + using ObjectWrapperBase::ObjectWrapperBase; + static constexpr const char *getTypeName() noexcept { + return "android/content/ContentUris"; + } + + /*! + * Wrapper for the appendId static method + * + * Java prototype: + * `public static android.net.Uri$Builder appendId(android.net.Uri$Builder, + * long);` + * + * JNI signature: (Landroid/net/Uri$Builder;J)Landroid/net/Uri$Builder; + * + */ + static net::Uri_Builder appendId(net::Uri_Builder &uri_Builder, + long long longParam); + + /*! + * Class metadata + */ + struct Meta : public MetaBaseDroppable { + jni::method_t appendId; + + /*! + * Singleton accessor + */ + static Meta &data(bool deferDrop = false) { + static Meta instance{deferDrop}; + return instance; + } + + private: + explicit Meta(bool deferDrop); + }; +}; + +/*! + * Wrapper for android.content.ComponentName objects. + */ +class ComponentName : public ObjectWrapperBase { + public: + using ObjectWrapperBase::ObjectWrapperBase; + static constexpr const char *getTypeName() noexcept { + return "android/content/ComponentName"; + } + + /*! + * Wrapper for a constructor + * + * Java prototype: + * `public android.content.ComponentName(java.lang.String, + * java.lang.String);` + * + * JNI signature: (Ljava/lang/String;Ljava/lang/String;)V + * + */ + static ComponentName construct(std::string const &pkg, + std::string const &className); + + /*! + * Wrapper for a constructor + * + * Java prototype: + * `public android.content.ComponentName(android.content.Context, + * java.lang.String);` + * + * JNI signature: (Landroid/content/Context;Ljava/lang/String;)V + * + */ + static ComponentName construct(Context const &context, + std::string const &className); + + /*! + * Wrapper for a constructor + * + * Java prototype: + * `public android.content.ComponentName(android.content.Context, + * java.lang.Class<?>);` + * + * JNI signature: (Landroid/content/Context;Ljava/lang/Class;)V + * + */ + static ComponentName construct(Context const &context, + jni::Object const &cls); + + /*! + * Wrapper for a constructor + * + * Java prototype: + * `public android.content.ComponentName(android.os.Parcel);` + * + * JNI signature: (Landroid/os/Parcel;)V + * + */ + static ComponentName construct(jni::Object const &parcel); + + /*! + * Class metadata + */ + struct Meta : public MetaBase { + jni::method_t init; + jni::method_t init1; + jni::method_t init2; + jni::method_t init3; + + /*! + * Singleton accessor + */ + static Meta &data() { + static Meta instance{}; + return instance; + } + + private: + Meta(); + }; +}; + +/*! + * Wrapper for android.content.ContentResolver objects. + */ +class ContentResolver : public ObjectWrapperBase { + public: + using ObjectWrapperBase::ObjectWrapperBase; + static constexpr const char *getTypeName() noexcept { + return "android/content/ContentResolver"; + } + + /*! + * Wrapper for the query method - overload added in API level 1 + * + * Java prototype: + * `public final android.database.Cursor query(android.net.Uri, + * java.lang.String[], java.lang.String, java.lang.String[], + * java.lang.String);` + * + * JNI signature: + * (Landroid/net/Uri;[Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;Ljava/lang/String;)Landroid/database/Cursor; + * + */ + database::Cursor query(net::Uri const &uri, + jni::Array<std::string> const &projection, + std::string const &selection, + jni::Array<std::string> const &selectionArgs, + std::string const &sortOrder); + + /*! + * Wrapper for the query method - overload added in API level 1 + * + * Java prototype: + * `public final android.database.Cursor query(android.net.Uri, + * java.lang.String[], java.lang.String, java.lang.String[], + * java.lang.String);` + * + * JNI signature: + * (Landroid/net/Uri;[Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;Ljava/lang/String;)Landroid/database/Cursor; + * + * This is a way to call the main query() function without the three + * trailing optional arguments. + */ + database::Cursor query(net::Uri const &uri, + jni::Array<std::string> const &projection); + + /*! + * Wrapper for the query method - overload added in API level 16 + * + * Java prototype: + * `public final android.database.Cursor query(android.net.Uri, + * java.lang.String[], java.lang.String, java.lang.String[], + * java.lang.String, android.os.CancellationSignal);` + * + * JNI signature: + * (Landroid/net/Uri;[Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;Ljava/lang/String;Landroid/os/CancellationSignal;)Landroid/database/Cursor; + * + */ + database::Cursor query(net::Uri const &uri, + jni::Array<std::string> const &projection, + std::string const &selection, + jni::Array<std::string> const &selectionArgs, + std::string const &sortOrder, + jni::Object const &cancellationSignal); + + /*! + * Wrapper for the query method - overload added in API level 26 + * + * Java prototype: + * `public final android.database.Cursor query(android.net.Uri, + * java.lang.String[], android.os.Bundle, android.os.CancellationSignal);` + * + * JNI signature: + * (Landroid/net/Uri;[Ljava/lang/String;Landroid/os/Bundle;Landroid/os/CancellationSignal;)Landroid/database/Cursor; + * + */ + database::Cursor query(net::Uri const &uri, + jni::Array<std::string> const &projection, + jni::Object const &queryArgs, + jni::Object const &cancellationSignal); + + /*! + * Class metadata + */ + struct Meta : public MetaBaseDroppable { + jni::method_t query; + jni::method_t query1; + jni::method_t query2; + + /*! + * Singleton accessor + */ + static Meta &data() { + static Meta instance{}; + return instance; + } + + private: + Meta(); + }; +}; + +} // namespace android::content +} // namespace wrap +#include "android.content.impl.h" diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.content.impl.h b/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.content.impl.h new file mode 100644 index 0000000..d16f504 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.content.impl.h @@ -0,0 +1,91 @@ +// Copyright 2020-2021, Collabora, Ltd. +// SPDX-License-Identifier: BSL-1.0 +// Author: Rylie Pavlik <rylie.pavlik@collabora.com> +// Inline implementations: do not include on its own! + +#pragma once + +#include "android.database.h" +#include "android.net.h" +#include <string> + +namespace wrap { +namespace android::content { +inline ContentResolver Context::getContentResolver() const { + assert(!isNull()); + return ContentResolver( + object().call<jni::Object>(Meta::data().getContentResolver)); +} + +inline net::Uri_Builder ContentUris::appendId(net::Uri_Builder &uri_Builder, + long long longParam) { + auto &data = Meta::data(true); + auto ret = net::Uri_Builder(data.clazz().call<jni::Object>( + data.appendId, uri_Builder.object(), longParam)); + data.dropClassRef(); + return ret; +} + +inline ComponentName ComponentName::construct(std::string const &pkg, + std::string const &className) { + return ComponentName( + Meta::data().clazz().newInstance(Meta::data().init, pkg, className)); +} + +inline ComponentName ComponentName::construct(Context const &context, + std::string const &className) { + return ComponentName(Meta::data().clazz().newInstance( + Meta::data().init1, context.object(), className)); +} + +inline ComponentName ComponentName::construct(Context const &context, + jni::Object const &cls) { + return ComponentName(Meta::data().clazz().newInstance( + Meta::data().init2, context.object(), cls)); +} + +inline ComponentName ComponentName::construct(jni::Object const &parcel) { + return ComponentName( + Meta::data().clazz().newInstance(Meta::data().init3, parcel)); +} + +inline database::Cursor ContentResolver::query( + net::Uri const &uri, jni::Array<std::string> const &projection, + std::string const &selection, jni::Array<std::string> const &selectionArgs, + std::string const &sortOrder) { + assert(!isNull()); + return database::Cursor( + object().call<jni::Object>(Meta::data().query, uri.object(), projection, + selection, selectionArgs, sortOrder)); +} + +inline database::Cursor +ContentResolver::query(net::Uri const &uri, + jni::Array<std::string> const &projection) { + assert(!isNull()); + return database::Cursor( + object().call<jni::Object>(Meta::data().query, uri.object(), projection, + nullptr, nullptr, nullptr)); +} + +inline database::Cursor ContentResolver::query( + net::Uri const &uri, jni::Array<std::string> const &projection, + std::string const &selection, jni::Array<std::string> const &selectionArgs, + std::string const &sortOrder, jni::Object const &cancellationSignal) { + assert(!isNull()); + return database::Cursor(object().call<jni::Object>( + Meta::data().query1, uri.object(), projection, selection, selectionArgs, + sortOrder, cancellationSignal)); +} + +inline database::Cursor ContentResolver::query( + net::Uri const &uri, jni::Array<std::string> const &projection, + jni::Object const &queryArgs, jni::Object const &cancellationSignal) { + assert(!isNull()); + return database::Cursor( + object().call<jni::Object>(Meta::data().query2, uri.object(), + projection, queryArgs, cancellationSignal)); +} + +} // namespace android::content +} // namespace wrap diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.database.cpp b/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.database.cpp new file mode 100644 index 0000000..05a0884 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.database.cpp @@ -0,0 +1,22 @@ +// Copyright 2020-2021, Collabora, Ltd. +// SPDX-License-Identifier: BSL-1.0 +// Author: Rylie Pavlik <rylie.pavlik@collabora.com> + +#include "android.database.h" + +namespace wrap { +namespace android::database { +Cursor::Meta::Meta() + : MetaBaseDroppable(Cursor::getTypeName()), + getCount(classRef().getMethod("getCount", "()I")), + moveToFirst(classRef().getMethod("moveToFirst", "()Z")), + moveToNext(classRef().getMethod("moveToNext", "()Z")), + getColumnIndex( + classRef().getMethod("getColumnIndex", "(Ljava/lang/String;)I")), + getString(classRef().getMethod("getString", "(I)Ljava/lang/String;")), + getInt(classRef().getMethod("getInt", "(I)I")), + close(classRef().getMethod("close", "()V")) { + MetaBaseDroppable::dropClassRef(); +} +} // namespace android::database +} // namespace wrap diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.database.h b/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.database.h new file mode 100644 index 0000000..be384f6 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.database.h @@ -0,0 +1,125 @@ +// Copyright 2020-2021, Collabora, Ltd. +// SPDX-License-Identifier: BSL-1.0 +// Author: Rylie Pavlik <rylie.pavlik@collabora.com> + +#pragma once + +#include "ObjectWrapperBase.h" + +namespace wrap { +namespace android::database { +/*! + * Wrapper for android.database.Cursor objects. + */ +class Cursor : public ObjectWrapperBase { + public: + using ObjectWrapperBase::ObjectWrapperBase; + static constexpr const char *getTypeName() noexcept { + return "android/database/Cursor"; + } + + /*! + * Wrapper for the getCount method + * + * Java prototype: + * `public abstract int getCount();` + * + * JNI signature: ()I + * + */ + int32_t getCount(); + + /*! + * Wrapper for the moveToFirst method + * + * Java prototype: + * `public abstract boolean moveToFirst();` + * + * JNI signature: ()Z + * + */ + bool moveToFirst(); + + /*! + * Wrapper for the moveToNext method + * + * Java prototype: + * `public abstract boolean moveToNext();` + * + * JNI signature: ()Z + * + */ + bool moveToNext(); + + /*! + * Wrapper for the getColumnIndex method + * + * Java prototype: + * `public abstract int getColumnIndex(java.lang.String);` + * + * JNI signature: (Ljava/lang/String;)I + * + */ + int32_t getColumnIndex(std::string const &columnName); + + /*! + * Wrapper for the getString method + * + * Java prototype: + * `public abstract java.lang.String getString(int);` + * + * JNI signature: (I)Ljava/lang/String; + * + */ + std::string getString(int32_t column); + + /*! + * Wrapper for the getInt method + * + * Java prototype: + * `public abstract int getInt(int);` + * + * JNI signature: (I)I + * + */ + int32_t getInt(int32_t column); + + /*! + * Wrapper for the close method + * + * Java prototype: + * `public abstract void close();` + * + * JNI signature: ()V + * + */ + void close(); + + /*! + * Class metadata + */ + struct Meta : public MetaBaseDroppable { + jni::method_t getCount; + jni::method_t moveToFirst; + jni::method_t moveToNext; + jni::method_t getColumnIndex; + jni::method_t getString; + jni::method_t getInt; + jni::method_t close; + + /*! + * Singleton accessor + */ + static Meta &data() { + static Meta instance{}; + return instance; + } + + private: + Meta(); + }; +}; + +} // namespace android::database +} // namespace wrap +#include "android.database.impl.h" diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.database.impl.h b/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.database.impl.h new file mode 100644 index 0000000..0c0d844 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.database.impl.h @@ -0,0 +1,48 @@ +// Copyright 2020-2021, Collabora, Ltd. +// SPDX-License-Identifier: BSL-1.0 +// Author: Rylie Pavlik <rylie.pavlik@collabora.com> +// Inline implementations: do not include on its own! + +#pragma once + +#include <string> + +namespace wrap { +namespace android::database { +inline int32_t Cursor::getCount() { + assert(!isNull()); + return object().call<int32_t>(Meta::data().getCount); +} + +inline bool Cursor::moveToFirst() { + assert(!isNull()); + return object().call<bool>(Meta::data().moveToFirst); +} + +inline bool Cursor::moveToNext() { + assert(!isNull()); + return object().call<bool>(Meta::data().moveToNext); +} + +inline int32_t Cursor::getColumnIndex(std::string const &columnName) { + assert(!isNull()); + return object().call<int32_t>(Meta::data().getColumnIndex, columnName); +} + +inline std::string Cursor::getString(int32_t column) { + assert(!isNull()); + return object().call<std::string>(Meta::data().getString, column); +} + +inline int32_t Cursor::getInt(int32_t column) { + assert(!isNull()); + return object().call<int32_t>(Meta::data().getInt, column); +} + +inline void Cursor::close() { + assert(!isNull()); + return object().call<void>(Meta::data().close); +} + +} // namespace android::database +} // namespace wrap diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.net.cpp b/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.net.cpp new file mode 100644 index 0000000..f46d5f5 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.net.cpp @@ -0,0 +1,27 @@ +// Copyright 2020-2021, Collabora, Ltd. +// SPDX-License-Identifier: BSL-1.0 +// Author: Rylie Pavlik <rylie.pavlik@collabora.com> + +#include "android.net.h" + +namespace wrap { +namespace android::net { +Uri::Meta::Meta() + : MetaBaseDroppable(Uri::getTypeName()), + toString(classRef().getMethod("toString", "()Ljava/lang/String;")) { + MetaBaseDroppable::dropClassRef(); +} +Uri_Builder::Meta::Meta() + : MetaBaseDroppable(Uri_Builder::getTypeName()), + init(classRef().getMethod("<init>", "()V")), + scheme(classRef().getMethod( + "scheme", "(Ljava/lang/String;)Landroid/net/Uri$Builder;")), + authority(classRef().getMethod( + "authority", "(Ljava/lang/String;)Landroid/net/Uri$Builder;")), + appendPath(classRef().getMethod( + "appendPath", "(Ljava/lang/String;)Landroid/net/Uri$Builder;")), + build(classRef().getMethod("build", "()Landroid/net/Uri;")) { + MetaBaseDroppable::dropClassRef(); +} +} // namespace android::net +} // namespace wrap diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.net.h b/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.net.h new file mode 100644 index 0000000..9485165 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.net.h @@ -0,0 +1,149 @@ +// Copyright 2020-2021, Collabora, Ltd. +// SPDX-License-Identifier: BSL-1.0 +// Author: Rylie Pavlik <rylie.pavlik@collabora.com> + +#pragma once + +#include "ObjectWrapperBase.h" + +namespace wrap { +namespace android::net { +class Uri; +class Uri_Builder; +} // namespace android::net + +} // namespace wrap + +namespace wrap { +namespace android::net { +/*! + * Wrapper for android.net.Uri objects. + */ +class Uri : public ObjectWrapperBase { + public: + using ObjectWrapperBase::ObjectWrapperBase; + static constexpr const char *getTypeName() noexcept { + return "android/net/Uri"; + } + + /*! + * Wrapper for the toString method + * + * Java prototype: + * `public abstract java.lang.String toString();` + * + * JNI signature: ()Ljava/lang/String; + * + */ + std::string toString() const; + + /*! + * Class metadata + */ + struct Meta : public MetaBaseDroppable { + jni::method_t toString; + + /*! + * Singleton accessor + */ + static Meta &data() { + static Meta instance{}; + return instance; + } + + private: + Meta(); + }; +}; + +/*! + * Wrapper for android.net.Uri$Builder objects. + */ +class Uri_Builder : public ObjectWrapperBase { + public: + using ObjectWrapperBase::ObjectWrapperBase; + static constexpr const char *getTypeName() noexcept { + return "android/net/Uri$Builder"; + } + + /*! + * Wrapper for a constructor + * + * Java prototype: + * `public android.net.Uri$Builder();` + * + * JNI signature: ()V + * + */ + static Uri_Builder construct(); + + /*! + * Wrapper for the scheme method + * + * Java prototype: + * `public android.net.Uri$Builder scheme(java.lang.String);` + * + * JNI signature: (Ljava/lang/String;)Landroid/net/Uri$Builder; + * + */ + Uri_Builder &scheme(std::string const &stringParam); + + /*! + * Wrapper for the authority method + * + * Java prototype: + * `public android.net.Uri$Builder authority(java.lang.String);` + * + * JNI signature: (Ljava/lang/String;)Landroid/net/Uri$Builder; + * + */ + Uri_Builder &authority(std::string const &stringParam); + + /*! + * Wrapper for the appendPath method + * + * Java prototype: + * `public android.net.Uri$Builder appendPath(java.lang.String);` + * + * JNI signature: (Ljava/lang/String;)Landroid/net/Uri$Builder; + * + */ + Uri_Builder &appendPath(std::string const &stringParam); + + /*! + * Wrapper for the build method + * + * Java prototype: + * `public android.net.Uri build();` + * + * JNI signature: ()Landroid/net/Uri; + * + */ + Uri build(); + + /*! + * Class metadata + */ + struct Meta : public MetaBaseDroppable { + jni::method_t init; + jni::method_t scheme; + jni::method_t authority; + jni::method_t appendPath; + jni::method_t build; + + /*! + * Singleton accessor + */ + static Meta &data() { + static Meta instance{}; + return instance; + } + + private: + Meta(); + }; +}; + +} // namespace android::net +} // namespace wrap +#include "android.net.impl.h" diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.net.impl.h b/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.net.impl.h new file mode 100644 index 0000000..f570c47 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/android-jni-wrappers/wrap/android.net.impl.h @@ -0,0 +1,45 @@ +// Copyright 2020-2021, Collabora, Ltd. +// SPDX-License-Identifier: BSL-1.0 +// Author: Rylie Pavlik <rylie.pavlik@collabora.com> +// Inline implementations: do not include on its own! + +#pragma once + +#include <string> + +namespace wrap { +namespace android::net { +inline std::string Uri::toString() const { + assert(!isNull()); + return object().call<std::string>(Meta::data().toString); +} + +inline Uri_Builder Uri_Builder::construct() { + return Uri_Builder(Meta::data().clazz().newInstance(Meta::data().init)); +} + +inline Uri_Builder &Uri_Builder::scheme(std::string const &stringParam) { + assert(!isNull()); + object().call<jni::Object>(Meta::data().scheme, stringParam); + return *this; +} + +inline Uri_Builder &Uri_Builder::authority(std::string const &stringParam) { + assert(!isNull()); + object().call<jni::Object>(Meta::data().authority, stringParam); + return *this; +} + +inline Uri_Builder &Uri_Builder::appendPath(std::string const &stringParam) { + assert(!isNull()); + object().call<jni::Object>(Meta::data().appendPath, stringParam); + return *this; +} + +inline Uri Uri_Builder::build() { + assert(!isNull()); + return Uri(object().call<jni::Object>(Meta::data().build)); +} + +} // namespace android::net +} // namespace wrap diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/CHANGELOG.md b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/CHANGELOG.md new file mode 100644 index 0000000..18851fc --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/CHANGELOG.md @@ -0,0 +1,8 @@ +# Changelog for jnipp + +## jnipp 1.0.0 (25-October-2023) + +This release is somewhat of a formality, as jnipp has been used in production +environments for some time. It was prompted by the need for an API breaking +change to ensure continued compatibility with libc++ as they move to more +strictly follow the C++ standard. diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/CMakeLists.txt b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/CMakeLists.txt new file mode 100644 index 0000000..9b0c187 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/CMakeLists.txt @@ -0,0 +1,19 @@ +# Copyright 2021, Collabora, Ltd. +# +# SPDX-License-Identifier: MIT + +cmake_minimum_required(VERSION 3.10.2) +project(jnipp) + +find_package(JNI REQUIRED) +include(CTest) + +add_library(jnipp jnipp.cpp) +target_include_directories( + jnipp + PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} + PRIVATE ${JNI_INCLUDE_DIRS}) +target_compile_features(jnipp PUBLIC cxx_std_11) +target_link_libraries(jnipp PUBLIC ${CMAKE_DL_LIBS}) + +add_subdirectory(tests) diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/LICENSE b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/LICENSE new file mode 100644 index 0000000..bda04ad --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2016 Mitchell Dowd + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/README.md b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/README.md new file mode 100644 index 0000000..178708b --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/README.md @@ -0,0 +1,107 @@ +# Java Native Interface for C++ + +## Overview + +JNIPP is just a C++ wrapper for the standard Java Native Interface (JNI). It +tries to take some of the long-winded annoyance out of integrating your Java +and C++ code. + +While this project has so far just been a utility library for my own usage, +it seems to have caught the eye of some others who have also been looking for +a suitable C++ JNI layer. If you have feature requests, do not hesitate to +submit them as Github issues. Please be descriptive in your feature request. +The more useful information you provide - along with justification on why it +should be implemented - the more likely it is that I will add your feature. + +## Requirements + +To compile you will need: + +- A C++11 compatible compiler +- An installation of the Java Development Kit (JDK) +- The `JAVA_HOME` environment variable, directed to your JDK installation. + +## Usage + +> For comprehensive examples on how to use *jnipp*, see the `tests` project +> in the project source code. + +There are two situations where the Java Native Interface would be needed. + +- A Java application calling C/C++ functions; or +- A C/C++ application calling Java methods + +### Calling Java from C++ + +The following is an example of calling Java from C++. + +```C++ +#include <jnipp.h> + +int main() +{ + // An instance of the Java VM needs to be created. + jni::Vm vm; + + // Create an instance of java.lang.Integer + jni::Class Integer = jni::Class("java/lang/Integer"); + jni::Object i = Integer.newInstance("1000"); + + // Call the `toString` method on that integer + std::string str = i.call<std::string>("toString"); + + // The Java VM is automatically destroyed when it goes out of scope. + return 0; +} +``` + +### Calling C++ from Java + +Consider a basic Java program: + +```Java +package com.example; + +class Demo { + public int value; + + public static void main(String[] args) { + Demo demo = new Demo(); + demo.value = 1000; + demo.run(); + } + + public native void run(); +} +``` + +A matching C++ library which uses *jnipp* could look like: + +```C++ +#include <jnipp.h> +#include <iostream> + +/* + The signature here is defind by the JNI standard, so must be adhered to. + Although, to prevent pollution of the global namespace, the JNIEnv and + jobject types defind by the standard JNI have been placed into the + jni namespace. + */ +extern "C" void Java_com_example_Demo_run(jni::JNIEnv* env, jni::jobject obj) +{ + // jnipp only needs initialising once, but it doesn't hurt to do it again. + jni::init(env); + + // Capture the supplied object. + jni::Object demo(obj); + + // Print the contents of the `value` field to stdout. + std::cout << demo.get<int>("value") << std::endl; +} +``` + +## Configuration + +By default, *jnipp* uses std::runtime_error as the base exception class. If you wish, +you can define `JNIPP_EXCEPTION_CLASS` to be the exception class you wish to use, before +including `jnipp.h`. It just needs a `const char*` constructor. diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/android/AndroidManifest.xml b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/android/AndroidManifest.xml new file mode 100644 index 0000000..7ea988b --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/android/AndroidManifest.xml @@ -0,0 +1,8 @@ +<?xml version="1.0" encoding="utf-8"?> +<!-- BEGIN_INCLUDE(manifest) --> +<manifest xmlns:android="http://schemas.android.com/apk/res/android" + package="jnipp" + android:versionCode="1" + android:versionName="1.0"> +</manifest> +<!-- END_INCLUDE(manifest) --> diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/android/CMakeLists.txt b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/android/CMakeLists.txt new file mode 100644 index 0000000..cca518d --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/android/CMakeLists.txt @@ -0,0 +1,12 @@ +CMAKE_MINIMUM_REQUIRED(VERSION 3.4.1) + +GET_FILENAME_COMPONENT(root_dir "../.." ABSOLUTE) + +LINK_DIRECTORIES("${root_dir}/${ANDROID_ABI}") + +SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${root_dir}/${ANDROID_ABI}") +SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DANDROID_STL=c++_static -std=gnu++11 -fexceptions") + +FILE(GLOB sources ../*.cpp ../common/*.cpp ../android/*.cpp) + +ADD_LIBRARY(jnipp SHARED ${sources}) diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/build.gradle b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/build.gradle new file mode 100644 index 0000000..a17e95a --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/build.gradle @@ -0,0 +1,30 @@ +apply plugin: 'com.android.library' + +android { + compileSdkVersion 26 + buildToolsVersion '28.0.3' + + defaultConfig { + minSdkVersion 15 + targetSdkVersion 26 + } + + buildTypes { + release { + minifyEnabled = false + proguardFiles getDefaultProguardFile('proguard-android.txt') + } + } + + sourceSets { + main { + manifest.srcFile 'android/AndroidManifest.xml' + } + } + + externalNativeBuild { + cmake { + path 'android/CMakeLists.txt' + } + } +} diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/changes/changes/pr.40.md b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/changes/changes/pr.40.md new file mode 100644 index 0000000..e5abd82 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/changes/changes/pr.40.md @@ -0,0 +1 @@ +Stop using `std::basic_string<jchar>` internally, because it is `std::basic_string<unsigned short>` on some platforms, and this specialization is not technically provided by the standard library. libc++ is removing support for it, so this internal change is required to continue to compile against libc++. In place of it, use `std::vector<jchar>`. diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/changes/fixes/pr.49.md b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/changes/fixes/pr.49.md new file mode 100644 index 0000000..c77aba7 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/changes/fixes/pr.49.md @@ -0,0 +1 @@ +Do not allow exceptions to escape destructors. diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/jnipp.cpp b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/jnipp.cpp new file mode 100644 index 0000000..a6c656a --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/jnipp.cpp @@ -0,0 +1,1658 @@ +#ifdef _WIN32 +# define WIN32_LEAN_AND_MEAN 1 + + // Windows Dependencies +# include <windows.h> +#else + // UNIX Dependencies +# include <dlfcn.h> +# include <unistd.h> +# include <tuple> +# include <stdlib.h> +#endif + +// External Dependencies +#include <jni.h> + +// Standard Dependencies +#include <atomic> +#include <string> +#include <vector> + +// Local Dependencies +#include "jnipp.h" + +namespace jni +{ + // Static Variables + static std::atomic_bool isVm(false); + static JavaVM* javaVm = nullptr; + + static bool getEnv(JavaVM *vm, JNIEnv **env) { + return vm->GetEnv((void **)env, JNI_VERSION_1_2) == JNI_OK; + } + + static bool isAttached(JavaVM *vm) { + JNIEnv *env = nullptr; + return getEnv(vm, &env); + } + /** + Maintains the lifecycle of a JNIEnv. + */ + class ScopedEnv final + { + public: + ScopedEnv() noexcept : _vm(nullptr), _env(nullptr), _attached(false) {} + ~ScopedEnv(); + + // Caution - throws if VM is nullptr! + void init(JavaVM* vm); + JNIEnv* get() const noexcept { return _env; } + + private: + // Instance Variables + JavaVM* _vm; + JNIEnv* _env; + bool _attached; ///< Manually attached, as opposed to already attached. + }; + + ScopedEnv::~ScopedEnv() + { + if (_vm && _attached) + _vm->DetachCurrentThread(); + } + + void ScopedEnv::init(JavaVM* vm) + { + if (_env != nullptr) + return; + + if (vm == nullptr) + throw InitializationException("JNI not initialized"); + + if (!getEnv(vm, &_env)) + { +#ifdef __ANDROID__ + if (vm->AttachCurrentThread(&_env, nullptr) != 0) +#else + if (vm->AttachCurrentThread((void**)&_env, nullptr) != 0) +#endif + throw InitializationException("Could not attach JNI to thread"); + + _attached = true; + } + + _vm = vm; + } + + /* + Helper Functions + */ + +#ifdef _WIN32 + + static bool fileExists(const std::string& filePath) + { + DWORD attr = ::GetFileAttributesA(filePath.c_str()); + + return attr != INVALID_FILE_ATTRIBUTES && !(attr & FILE_ATTRIBUTE_DIRECTORY); + } + +#else + + /** + Convert from a UTF-16 Java string to a UTF-32 string. + */ + std::wstring toWString(const jchar* str, jsize length) + { + std::wstring result; + + result.reserve(length); + + for (jsize i = 0; i < length; ++i) + { + wchar_t ch = str[i]; + + // Check for a two-segment character. + if (ch >= wchar_t(0xD800) && ch <= wchar_t(0xDBFF)) { + if (i + 1 >= length) + break; + + // Create a single, 32-bit character. + ch = (ch - wchar_t(0xD800)) << 10; + ch += str[i++] - wchar_t(0x1DC00); + } + + result += ch; + } + + return result; + } + + /** + Convert from a UTF-32 string to a UTF-16 Java string. + */ + std::vector<jchar> toJString(const wchar_t* str, size_t length) + { + std::vector<jchar> result; + + result.reserve(length * 2); // Worst case scenario. + + for (size_t i = 0; i < length; ++i) + { + wchar_t ch = str[i]; + + // Check for multi-byte UTF-16 character. + if (ch > wchar_t(0xFFFF)) { + ch -= uint32_t(0x10000); + + // Add the first of the two-segment character. + result.push_back(jchar(0xD800 + (ch >> 10))); + ch = wchar_t(0xDC00) + (ch & 0x03FF); + } + + result.push_back(jchar(ch)); + } + + return result; + } + +#endif // _WIN32 + + static ScopedEnv &scopedEnvInstance() noexcept + { + static thread_local ScopedEnv env; + return env; + } + + // may return nullptr, beware! + JNIEnv *env_noexcept() noexcept + { + ScopedEnv& env = scopedEnvInstance(); + if (env.get() != nullptr && !isAttached(javaVm)) + { + // we got detached, so clear it. + // will be re-populated from static javaVm below. + env = ScopedEnv{}; + } + + if (env.get() == nullptr && javaVm != nullptr) + { + env.init(javaVm); + } + + return env.get(); + } + + JNIEnv* env() + { + JNIEnv *ret = env_noexcept(); + if (ret == nullptr) + { + throw InitializationException("JNI not initialized"); + } + + return ret; + } + + static jclass findClass(const char* name) + { + jclass ref = env()->FindClass(name); + + if (ref == nullptr) + { + env()->ExceptionClear(); + throw NameResolutionException(name); + } + + return ref; + } + + static void handleJavaExceptions() + { + JNIEnv* env = jni::env(); + + jthrowable exception = env->ExceptionOccurred(); + + if (exception != nullptr) + { + Object obj(exception, Object::Temporary); + + env->ExceptionClear(); + std::string msg = obj.call<std::string>("toString"); + throw InvocationException(msg.c_str()); + } + } + + static std::string toString(jobject handle, bool deleteLocal = true) + { + std::string result; + + if (handle != nullptr) + { + JNIEnv* env = jni::env(); + + const char* chars = env->GetStringUTFChars(jstring(handle), nullptr); + result.assign(chars, env->GetStringUTFLength(jstring(handle))); + env->ReleaseStringUTFChars(jstring(handle), chars); + + if (deleteLocal) + env->DeleteLocalRef(handle); + } + + return result; + } + + static std::wstring toWString(jobject handle, bool deleteLocal = true) + { + std::wstring result; + + if (handle != nullptr) + { + JNIEnv* env = jni::env(); + + const jchar* chars = env->GetStringChars(jstring(handle), nullptr); +#ifdef _WIN32 + result.assign((const wchar_t*) chars, env->GetStringLength(jstring(handle))); +#else + result = toWString(chars, env->GetStringLength(jstring(handle))); +#endif + env->ReleaseStringChars(jstring(handle), chars); + + if (deleteLocal) + env->DeleteLocalRef(handle); + } + + return result; + } + + + /* + Stand-alone Function Implementations + */ + + void init(JNIEnv* env) + { + bool expected = false; + + if (isVm.compare_exchange_strong(expected, true)) + { + if (javaVm == nullptr && env->GetJavaVM(&javaVm) != 0) + throw InitializationException("Could not acquire Java VM"); + } + } + + void init(JavaVM* vm) { + bool expected = false; + + if (isVm.compare_exchange_strong(expected, true)) + { + javaVm = vm; + } + } + /* + Object Implementation + */ + + Object::Object() noexcept : _handle(nullptr), _class(nullptr), _isGlobal(false) + { + } + + Object::Object(const Object& other) : _handle(nullptr), _class(nullptr), _isGlobal(!other.isNull()) + { + if (!other.isNull()) + _handle = env()->NewGlobalRef(other._handle); + } + + Object::Object(Object&& other) noexcept : _handle(other._handle), _class(other._class), _isGlobal(other._isGlobal) + { + other._handle = nullptr; + other._class = nullptr; + other._isGlobal = false; + } + + Object::Object(jobject ref, int scopeFlags) : _handle(ref), _class(nullptr), _isGlobal((scopeFlags & Temporary) == 0) + { + if (!_isGlobal) + return; + + JNIEnv* env = jni::env(); + + _handle = env->NewGlobalRef(ref); + + if (scopeFlags & DeleteLocalInput) + env->DeleteLocalRef(ref); + } + + Object::~Object() noexcept + { + JNIEnv* env = jni::env_noexcept(); + if (env == nullptr) + { + // Better be empty. Cannot do anything useful. + return; + } + + if (_isGlobal && _handle != nullptr) + env->DeleteGlobalRef(_handle); + + if (_class != nullptr) + env->DeleteGlobalRef(_class); + } + + Object& Object::operator=(const Object& other) + { + if (_handle != other._handle) + { + JNIEnv* env = jni::env(); + + // Ditch the old reference. + if (_isGlobal) + env->DeleteGlobalRef(_handle); + if (_class != nullptr) + env->DeleteGlobalRef(_class); + + // Assign the new reference. + if ((_isGlobal = !other.isNull()) != false) + _handle = env->NewGlobalRef(other._handle); + + _class = nullptr; + } + + return *this; + } + + bool Object::operator==(const Object& other) const + { + return env()->IsSameObject(_handle, other._handle) != JNI_FALSE; + } + + Object& Object::operator=(Object&& other) + { + if (_handle != other._handle) + { + JNIEnv* env = jni::env(); + + // Ditch the old reference. + if (_isGlobal) + env->DeleteGlobalRef(_handle); + if (_class != nullptr) + env->DeleteGlobalRef(_class); + + // Assign the new reference. + _handle = other._handle; + _isGlobal = other._isGlobal; + _class = other._class; + + other._handle = nullptr; + other._isGlobal = false; + other._class = nullptr; + } + + return *this; + } + + bool Object::isNull() const noexcept + { + return _handle == nullptr || env()->IsSameObject(_handle, nullptr); + } + + void Object::callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<void> const&) const + { + env()->CallVoidMethodA(_handle, method, (jvalue*) args); + handleJavaExceptions(); + } + + bool Object::callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<bool> const&) const + { + auto result = env()->CallBooleanMethodA(_handle, method, (jvalue*) args); + handleJavaExceptions(); + return result != 0; + } + + bool Object::getFieldValue(field_t field, internal::ReturnTypeWrapper<bool> const&) const + { + return env()->GetBooleanField(_handle, field) != 0; + } + + template <> void Object::set(field_t field, const bool& value) + { + env()->SetBooleanField(_handle, field, value); + } + + byte_t Object::callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<byte_t> const&) const + { + auto result = env()->CallByteMethodA(_handle, method, (jvalue*) args); + handleJavaExceptions(); + return result; + } + + wchar_t Object::callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<wchar_t> const&) const + { + auto result = env()->CallCharMethodA(_handle, method, (jvalue*) args); + handleJavaExceptions(); + return result; + } + + short Object::callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<short> const&) const + { + auto result = env()->CallShortMethodA(_handle, method, (jvalue*) args); + handleJavaExceptions(); + return result; + } + + int Object::callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<int> const&) const + { + auto result = env()->CallIntMethodA(_handle, method, (jvalue*) args); + handleJavaExceptions(); + return result; + } + + long long Object::callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<long long> const&) const + { + auto result = env()->CallLongMethodA(_handle, method, (jvalue*) args); + handleJavaExceptions(); + return result; + } + + float Object::callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<float> const&) const + { + auto result = env()->CallFloatMethodA(_handle, method, (jvalue*) args); + handleJavaExceptions(); + return result; + } + + double Object::callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<double> const&) const + { + auto result = env()->CallDoubleMethodA(_handle, method, (jvalue*) args); + handleJavaExceptions(); + return result; + } + + std::string Object::callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<std::string> const&) const + { + auto result = env()->CallObjectMethodA(_handle, method, (jvalue*) args); + handleJavaExceptions(); + return toString(result); + } + + std::wstring Object::callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<std::wstring> const&) const + { + auto result = env()->CallObjectMethodA(_handle, method, (jvalue*) args); + handleJavaExceptions(); + return toWString(result); + } + + jni::Object Object::callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<jni::Object> const&) const + { + auto result = env()->CallObjectMethodA(_handle, method, (jvalue*) args); + handleJavaExceptions(); + return Object(result, DeleteLocalInput); + } + + jarray Object::callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<jarray> const&) const + { + auto result = env()->CallObjectMethodA(_handle, method, (jvalue*) args); + handleJavaExceptions(); + return (jarray)result; + } + + byte_t Object::getFieldValue(field_t field, internal::ReturnTypeWrapper<byte_t> const&) const + { + return env()->GetByteField(_handle, field); + } + + wchar_t Object::getFieldValue(field_t field, internal::ReturnTypeWrapper<wchar_t> const&) const + { + return env()->GetCharField(_handle, field); + } + + short Object::getFieldValue(field_t field, internal::ReturnTypeWrapper<short> const&) const + { + return env()->GetShortField(_handle, field); + } + + int Object::getFieldValue(field_t field, internal::ReturnTypeWrapper<int> const&) const + { + return env()->GetIntField(_handle, field); + } + + long long Object::getFieldValue(field_t field, internal::ReturnTypeWrapper<long long> const&) const + { + return env()->GetLongField(_handle, field); + } + + float Object::getFieldValue(field_t field, internal::ReturnTypeWrapper<float> const&) const + { + return env()->GetFloatField(_handle, field); + } + + double Object::getFieldValue(field_t field, internal::ReturnTypeWrapper<double> const&) const + { + return env()->GetDoubleField(_handle, field); + } + + std::string Object::getFieldValue(field_t field, internal::ReturnTypeWrapper<std::string> const&) const + { + return toString(env()->GetObjectField(_handle, field)); + } + + std::wstring Object::getFieldValue(field_t field, internal::ReturnTypeWrapper<std::wstring> const&) const + { + return toWString(env()->GetObjectField(_handle, field)); + } + + Object Object::getFieldValue(field_t field, internal::ReturnTypeWrapper<Object> const&) const + { + return Object(env()->GetObjectField(_handle, field), DeleteLocalInput); + } + + template <> void Object::set(field_t field, const byte_t& value) + { + env()->SetByteField(_handle, field, value); + } + + template <> void Object::set(field_t field, const wchar_t& value) + { + env()->SetCharField(_handle, field, value); + } + + template <> void Object::set(field_t field, const short& value) + { + env()->SetShortField(_handle, field, value); + } + + template <> void Object::set(field_t field, const int& value) + { + env()->SetIntField(_handle, field, value); + } + + template <> void Object::set(field_t field, const long long& value) + { + env()->SetLongField(_handle, field, value); + } + + template <> void Object::set(field_t field, const float& value) + { + env()->SetFloatField(_handle, field, value); + } + + template <> void Object::set(field_t field, const double& value) + { + env()->SetDoubleField(_handle, field, value); + } + + template <> void Object::set(field_t field, const std::string& value) + { + JNIEnv* env = jni::env(); + + jobject handle = env->NewStringUTF(value.c_str()); + env->SetObjectField(_handle, field, handle); + env->DeleteLocalRef(handle); + } + + template <> void Object::set(field_t field, const std::wstring& value) + { + JNIEnv* env = jni::env(); + +#ifdef _WIN32 + jobject handle = env->NewString((const jchar*) value.c_str(), jsize(value.length())); +#else + auto jstr = toJString(value.c_str(), value.length()); + jobject handle = env->NewString(jstr.data(), jsize(jstr.size())); +#endif + env->SetObjectField(_handle, field, handle); + env->DeleteLocalRef(handle); + } + + template <> void Object::set(field_t field, const wchar_t* const& value) + { + JNIEnv* env = jni::env(); +#ifdef _WIN32 + jobject handle = env->NewString((const jchar*) value, jsize(std::wcslen(value))); +#else + auto jstr = toJString(value, std::wcslen(value)); + jobject handle = env->NewString(jstr.data(), jsize(jstr.size())); +#endif + env->SetObjectField(_handle, field, handle); + env->DeleteLocalRef(handle); + } + + template <> void Object::set(field_t field, const char* const& value) + { + JNIEnv* env = jni::env(); + + jobject handle = env->NewStringUTF(value); + env->SetObjectField(_handle, field, handle); + env->DeleteLocalRef(handle); + } + + template <> void Object::set(field_t field, const Object& value) + { + env()->SetObjectField(_handle, field, value.getHandle()); + } + + template <> void Object::set(field_t field, const Object* const& value) + { + env()->SetObjectField(_handle, field, value ? value->getHandle() : nullptr); + } + + jclass Object::getClass() const + { + if (_class == nullptr) + { + JNIEnv* env = jni::env(); + + jclass classRef = env->GetObjectClass(_handle); + _class = jclass(env->NewGlobalRef(classRef)); + env->DeleteLocalRef(classRef); + } + + return _class; + } + + method_t Object::getMethod(const char* name, const char* signature) const + { + return Class(getClass(), Temporary).getMethod(name, signature); + } + + method_t Object::getMethod(const char* nameAndSignature) const + { + return Class(getClass(), Temporary).getMethod(nameAndSignature); + } + + field_t Object::getField(const char* name, const char* signature) const + { + return Class(getClass(), Temporary).getField(name, signature); + } + + jobject Object::makeLocalReference() const + { + if (isNull()) + return nullptr; + return env()->NewLocalRef(_handle); + } + + /* + Class Implementation + */ + + Class::Class(const char* name) : Object(findClass(name), DeleteLocalInput) + { + } + + Class::Class(jclass ref, int scopeFlags) : Object(ref, scopeFlags) + { + } + + Object Class::newInstance() const + { + method_t constructor = getMethod("<init>", "()V"); + jobject obj = env()->NewObject(getHandle(), constructor); + + handleJavaExceptions(); + + return Object(obj, Object::DeleteLocalInput); + } + + field_t Class::getField(const char* name, const char* signature) const + { + jfieldID id = env()->GetFieldID(getHandle(), name, signature); + + if (id == nullptr) + throw NameResolutionException(name); + + return id; + } + + field_t Class::getStaticField(const char* name, const char* signature) const + { + jfieldID id = env()->GetStaticFieldID(getHandle(), name, signature); + + if (id == nullptr) + throw NameResolutionException(name); + + return id; + } + + method_t Class::getMethod(const char* name, const char* signature) const + { + jmethodID id = env()->GetMethodID(getHandle(), name, signature); + + if (id == nullptr) + throw NameResolutionException(name); + + return id; + } + + + method_t Class::getMethod(const char* nameAndSignature) const + { + jmethodID id = nullptr; + const char* sig = std::strchr(nameAndSignature, '('); + + if (sig != nullptr) + return getMethod(std::string(nameAndSignature, sig - nameAndSignature).c_str(), sig); + + if (id == nullptr) + throw NameResolutionException(nameAndSignature); + + return id; + } + + method_t Class::getStaticMethod(const char* name, const char* signature) const + { + jmethodID id = env()->GetStaticMethodID(getHandle(), name, signature); + + if (id == nullptr) + throw NameResolutionException(name); + + return id; + } + + method_t Class::getStaticMethod(const char* nameAndSignature) const + { + jmethodID id = nullptr; + const char* sig = std::strchr(nameAndSignature, '('); + + if (sig != nullptr) + return getStaticMethod(std::string(nameAndSignature, sig - nameAndSignature).c_str(), sig); + + if (id == nullptr) + throw NameResolutionException(nameAndSignature); + + return id; + } + + Class Class::getParent() const + { + return Class(env()->GetSuperclass(getHandle()), DeleteLocalInput); + } + + std::string Class::getName() const + { + return Object::call<std::string>("getName"); + } + + template <> bool Class::get(field_t field) const + { + return env()->GetStaticBooleanField(getHandle(), field) != 0; + } + + template <> byte_t Class::get(field_t field) const + { + return env()->GetStaticByteField(getHandle(), field); + } + + template <> wchar_t Class::get(field_t field) const + { + return env()->GetStaticCharField(getHandle(), field); + } + + template <> short Class::get(field_t field) const + { + return env()->GetStaticShortField(getHandle(), field); + } + + template <> int Class::get(field_t field) const + { + return env()->GetStaticIntField(getHandle(), field); + } + + template <> long long Class::get(field_t field) const + { + return env()->GetStaticLongField(getHandle(), field); + } + + template <> float Class::get(field_t field) const + { + return env()->GetStaticFloatField(getHandle(), field); + } + + template <> double Class::get(field_t field) const + { + return env()->GetStaticDoubleField(getHandle(), field); + } + + template <> std::string Class::get(field_t field) const + { + return toString(env()->GetStaticObjectField(getHandle(), field)); + } + + template <> std::wstring Class::get(field_t field) const + { + return toWString(env()->GetStaticObjectField(getHandle(), field)); + } + + template <> Object Class::get(field_t field) const + { + return Object(env()->GetStaticObjectField(getHandle(), field), DeleteLocalInput); + } + + template <> void Class::set(field_t field, const bool& value) + { + env()->SetStaticBooleanField(getHandle(), field, value); + } + + template <> void Class::set(field_t field, const byte_t& value) + { + env()->SetStaticByteField(getHandle(), field, value); + } + + template <> void Class::set(field_t field, const wchar_t& value) + { + env()->SetStaticCharField(getHandle(), field, value); + } + + template <> void Class::set(field_t field, const short& value) + { + env()->SetStaticShortField(getHandle(), field, value); + } + + template <> void Class::set(field_t field, const int& value) + { + env()->SetStaticIntField(getHandle(), field, value); + } + + template <> void Class::set(field_t field, const long long& value) + { + env()->SetStaticLongField(getHandle(), field, value); + } + + template <> void Class::set(field_t field, const float& value) + { + env()->SetStaticFloatField(getHandle(), field, value); + } + + template <> void Class::set(field_t field, const double& value) + { + env()->SetStaticDoubleField(getHandle(), field, value); + } + + template <> void Class::set(field_t field, const Object& value) + { + env()->SetStaticObjectField(getHandle(), field, value.getHandle()); + } + + template <> void Class::set(field_t field, const Object* const& value) + { + env()->SetStaticObjectField(getHandle(), field, value ? value->getHandle() : nullptr); + } + + template <> void Class::set(field_t field, const std::string& value) + { + JNIEnv* env = jni::env(); + + jobject handle = env->NewStringUTF(value.c_str()); + env->SetStaticObjectField(getHandle(), field, handle); + env->DeleteLocalRef(handle); + } + + template <> void Class::set(field_t field, const std::wstring& value) + { + JNIEnv* env = jni::env(); + +#ifdef _WIN32 + jobject handle = env->NewString((const jchar*) value.c_str(), jsize(value.length())); +#else + auto jstr = toJString(value.c_str(), value.length()); + jobject handle = env->NewString(jstr.data(), jsize(jstr.size())); +#endif + env->SetStaticObjectField(getHandle(), field, handle); + env->DeleteLocalRef(handle); + } + + template <> void Class::callStaticMethod(method_t method, internal::value_t* args) const + { + env()->CallStaticVoidMethodA(getHandle(), method, (jvalue*) args); + handleJavaExceptions(); + } + + template <> bool Class::callStaticMethod(method_t method, internal::value_t* args) const + { + auto result = env()->CallStaticBooleanMethodA(getHandle(), method, (jvalue*) args); + handleJavaExceptions(); + return result != 0; + } + + template <> byte_t Class::callStaticMethod(method_t method, internal::value_t* args) const + { + auto result = env()->CallStaticByteMethodA(getHandle(), method, (jvalue*) args); + handleJavaExceptions(); + return result; + } + + template <> wchar_t Class::callStaticMethod(method_t method, internal::value_t* args) const + { + auto result = env()->CallStaticCharMethodA(getHandle(), method, (jvalue*) args); + handleJavaExceptions(); + return result; + } + + template <> short Class::callStaticMethod(method_t method, internal::value_t* args) const + { + auto result = env()->CallStaticShortMethodA(getHandle(), method, (jvalue*) args); + handleJavaExceptions(); + return result; + } + + template <> int Class::callStaticMethod(method_t method, internal::value_t* args) const + { + auto result = env()->CallStaticIntMethodA(getHandle(), method, (jvalue*) args); + handleJavaExceptions(); + return result; + } + + template <> long long Class::callStaticMethod(method_t method, internal::value_t* args) const + { + auto result = env()->CallStaticLongMethodA(getHandle(), method, (jvalue*) args); + handleJavaExceptions(); + return result; + } + + template <> float Class::callStaticMethod(method_t method, internal::value_t* args) const + { + auto result = env()->CallStaticFloatMethodA(getHandle(), method, (jvalue*) args); + handleJavaExceptions(); + return result; + } + + template <> double Class::callStaticMethod(method_t method, internal::value_t* args) const + { + auto result = env()->CallStaticDoubleMethodA(getHandle(), method, (jvalue*) args); + handleJavaExceptions(); + return result; + } + + template <> std::string Class::callStaticMethod(method_t method, internal::value_t* args) const + { + auto result = env()->CallStaticObjectMethodA(getHandle(), method, (jvalue*) args); + handleJavaExceptions(); + return toString(result); + } + + template <> std::wstring Class::callStaticMethod(method_t method, internal::value_t* args) const + { + auto result = env()->CallStaticObjectMethodA(getHandle(), method, (jvalue*) args); + handleJavaExceptions(); + return toWString(result); + } + + template <> jni::Object Class::callStaticMethod(method_t method, internal::value_t* args) const + { + auto result = env()->CallStaticObjectMethodA(getHandle(), method, (jvalue*) args); + handleJavaExceptions(); + return Object(result, DeleteLocalInput); + } + + template <> void Class::callExactMethod(jobject obj, method_t method, internal::value_t* args) const + { + env()->CallNonvirtualVoidMethodA(obj, getHandle(), method, (jvalue*) args); + handleJavaExceptions(); + } + + template <> bool Class::callExactMethod(jobject obj, method_t method, internal::value_t* args) const + { + auto result = env()->CallNonvirtualBooleanMethodA(obj, getHandle(), method, (jvalue*) args); + handleJavaExceptions(); + return result != 0; + } + + template <> byte_t Class::callExactMethod(jobject obj, method_t method, internal::value_t* args) const + { + auto result = env()->CallNonvirtualByteMethodA(obj, getHandle(), method, (jvalue*) args); + handleJavaExceptions(); + return result; + } + + template <> wchar_t Class::callExactMethod(jobject obj, method_t method, internal::value_t* args) const + { + auto result = env()->CallNonvirtualCharMethodA(obj, getHandle(), method, (jvalue*) args); + handleJavaExceptions(); + return result; + } + + template <> short Class::callExactMethod(jobject obj, method_t method, internal::value_t* args) const + { + auto result = env()->CallNonvirtualShortMethodA(obj, getHandle(), method, (jvalue*) args); + handleJavaExceptions(); + return result; + } + + template <> int Class::callExactMethod(jobject obj, method_t method, internal::value_t* args) const + { + auto result = env()->CallNonvirtualIntMethodA(obj, getHandle(), method, (jvalue*) args); + handleJavaExceptions(); + return result; + } + + template <> long long Class::callExactMethod(jobject obj, method_t method, internal::value_t* args) const + { + auto result = env()->CallNonvirtualLongMethodA(obj, getHandle(), method, (jvalue*) args); + handleJavaExceptions(); + return result; + } + + template <> float Class::callExactMethod(jobject obj, method_t method, internal::value_t* args) const + { + auto result = env()->CallNonvirtualFloatMethodA(obj, getHandle(), method, (jvalue*) args); + handleJavaExceptions(); + return result; + } + + template <> double Class::callExactMethod(jobject obj, method_t method, internal::value_t* args) const + { + auto result = env()->CallNonvirtualDoubleMethodA(obj, getHandle(), method, (jvalue*) args); + handleJavaExceptions(); + return result; + } + + template <> std::string Class::callExactMethod(jobject obj, method_t method, internal::value_t* args) const + { + auto result = env()->CallNonvirtualObjectMethodA(obj, getHandle(), method, (jvalue*)args); + handleJavaExceptions(); + return toString(result); + } + + template <> std::wstring Class::callExactMethod(jobject obj, method_t method, internal::value_t* args) const + { + auto result = env()->CallNonvirtualObjectMethodA(obj, getHandle(), method, (jvalue*)args); + handleJavaExceptions(); + return toWString(result); + } + + template <> Object Class::callExactMethod(jobject obj, method_t method, internal::value_t* args) const + { + auto result = env()->CallNonvirtualObjectMethodA(obj, getHandle(), method, (jvalue*)args); + handleJavaExceptions(); + return Object(result, DeleteLocalInput); + } + + Object Class::newObject(method_t constructor, internal::value_t* args) const + { + jobject ref = env()->NewObjectA(getHandle(), constructor, (jvalue*)args); + handleJavaExceptions(); + return Object(ref, DeleteLocalInput); + } + + /* + Enum Implementation + */ + + Enum::Enum(const char* name) : Class(name) + { + _name = "L"; + _name += name; + _name += ";"; + } + + Object Enum::get(const char* name) const + { + return Class::get<Object>(getStaticField(name, _name.c_str())); + } + + /* + Array Implementation + */ + + template <> Array<bool>::Array(long length) : Object(env()->NewBooleanArray(length)), _length(length) + { + } + + template <> Array<byte_t>::Array(long length) : Object(env()->NewByteArray(length)), _length(length) + { + } + + template <> Array<wchar_t>::Array(long length) : Object(env()->NewCharArray(length)), _length(length) + { + } + + template <> Array<short>::Array(long length) : Object(env()->NewShortArray(length)), _length(length) + { + } + + template <> Array<int>::Array(long length) : Object(env()->NewIntArray(length)), _length(length) + { + } + + template <> Array<long long>::Array(long length) : Object(env()->NewLongArray(length)), _length(length) + { + } + + template <> Array<float>::Array(long length) : Object(env()->NewFloatArray(length)), _length(length) + { + } + + template <> Array<double>::Array(long length) : Object(env()->NewDoubleArray(length)), _length(length) + { + } + + template <> Array<std::string>::Array(long length) : Object(env()->NewObjectArray(length, Class("java/lang/String").getHandle(), nullptr)), _length(length) + { + } + + template <> Array<std::wstring>::Array(long length) : Object(env()->NewObjectArray(length, Class("java/lang/String").getHandle(), nullptr)), _length(length) + { + } + + template <> Array<Object>::Array(long length) : Object(env()->NewObjectArray(length, Class("java/lang/Object").getHandle(), nullptr)), _length(length) + { + } + + template <> Array<Object>::Array(long length, const Class& type) : Object(env()->NewObjectArray(length, type.getHandle(), nullptr)), _length(length) + { + } + + template <> bool Array<bool>::getElement(long index) const + { + jboolean output; + env()->GetBooleanArrayRegion(jbooleanArray(getHandle()), index, 1, &output); + handleJavaExceptions(); + return output; + } + + template <> byte_t Array<byte_t>::getElement(long index) const + { + jbyte output; + env()->GetByteArrayRegion(jbyteArray(getHandle()), index, 1, &output); + handleJavaExceptions(); + return output; + } + + template <> wchar_t Array<wchar_t>::getElement(long index) const + { + jchar output; + env()->GetCharArrayRegion(jcharArray(getHandle()), index, 1, &output); + handleJavaExceptions(); + return output; + } + + template <> short Array<short>::getElement(long index) const + { + jshort output; + env()->GetShortArrayRegion(jshortArray(getHandle()), index, 1, &output); + handleJavaExceptions(); + return output; + } + + template <> int Array<int>::getElement(long index) const + { + jint output; + env()->GetIntArrayRegion(jintArray(getHandle()), index, 1, &output); + handleJavaExceptions(); + return output; + } + + template <> long long Array<long long>::getElement(long index) const + { + jlong output; + env()->GetLongArrayRegion(jlongArray(getHandle()), index, 1, &output); + handleJavaExceptions(); + return output; + } + + template <> float Array<float>::getElement(long index) const + { + jfloat output; + env()->GetFloatArrayRegion(jfloatArray(getHandle()), index, 1, &output); + handleJavaExceptions(); + return output; + } + + template <> double Array<double>::getElement(long index) const + { + jdouble output; + env()->GetDoubleArrayRegion(jdoubleArray(getHandle()), index, 1, &output); + handleJavaExceptions(); + return output; + } + + template <> std::string Array<std::string>::getElement(long index) const + { + jobject output = env()->GetObjectArrayElement(jobjectArray(getHandle()), index); + handleJavaExceptions(); + return toString(output); + } + + template <> std::wstring Array<std::wstring>::getElement(long index) const + { + jobject output = env()->GetObjectArrayElement(jobjectArray(getHandle()), index); + handleJavaExceptions(); + return toWString(output); + } + + template <> Object Array<Object>::getElement(long index) const + { + jobject output = env()->GetObjectArrayElement(jobjectArray(getHandle()), index); + handleJavaExceptions(); + return Object(output, DeleteLocalInput); + } + + template <> void Array<bool>::setElement(long index, bool value) + { + jboolean jvalue = value; + env()->SetBooleanArrayRegion(jbooleanArray(getHandle()), index, 1, &jvalue); + handleJavaExceptions(); + } + + template <> void Array<byte_t>::setElement(long index, byte_t value) + { + jbyte jvalue = value; + env()->SetByteArrayRegion(jbyteArray(getHandle()), index, 1, &jvalue); + handleJavaExceptions(); + } + + template <> void Array<wchar_t>::setElement(long index, wchar_t value) + { + jchar jvalue = value; + env()->SetCharArrayRegion(jcharArray(getHandle()), index, 1, &jvalue); + handleJavaExceptions(); + } + + template <> void Array<short>::setElement(long index, short value) + { + jshort jvalue = value; + env()->SetShortArrayRegion(jshortArray(getHandle()), index, 1, &jvalue); + handleJavaExceptions(); + } + + template <> void Array<int>::setElement(long index, int value) + { + jint jvalue = value; + env()->SetIntArrayRegion(jintArray(getHandle()), index, 1, &jvalue); + handleJavaExceptions(); + } + + template <> void Array<long long>::setElement(long index, long long value) + { + jlong jvalue = value; + env()->SetLongArrayRegion(jlongArray(getHandle()), index, 1, &jvalue); + handleJavaExceptions(); + } + + template <> void Array<float>::setElement(long index, float value) + { + jfloat jvalue = value; + env()->SetFloatArrayRegion(jfloatArray(getHandle()), index, 1, &jvalue); + handleJavaExceptions(); + } + + template <> void Array<double>::setElement(long index, double value) + { + jdouble jvalue = value; + env()->SetDoubleArrayRegion(jdoubleArray(getHandle()), index, 1, &jvalue); + handleJavaExceptions(); + } + + template <> void Array<std::string>::setElement(long index, std::string value) + { + JNIEnv* env = jni::env(); + + jobject jvalue = env->NewStringUTF(value.c_str());; + env->SetObjectArrayElement(jobjectArray(getHandle()), index, jvalue); + env->DeleteLocalRef(jvalue); + handleJavaExceptions(); + } + + template <> void Array<std::wstring>::setElement(long index, std::wstring value) + { + JNIEnv* env = jni::env(); + +#ifdef _WIN32 + jobject jvalue = env->NewString((const jchar*) value.c_str(), jsize(value.length())); +#else + auto jstr = toJString(value.c_str(), value.length()); + jobject jvalue = env->NewString(jstr.data(), jsize(jstr.size())); +#endif + env->SetObjectArrayElement(jobjectArray(getHandle()), index, jvalue); + env->DeleteLocalRef(jvalue); + handleJavaExceptions(); + } + + template <> void Array<Object>::setElement(long index, Object value) + { + env()->SetObjectArrayElement(jobjectArray(getHandle()), index, value.getHandle()); + handleJavaExceptions(); + } + + /* + Vm Implementation + */ + + typedef jint (JNICALL *CreateVm_t)(JavaVM**, void**, void*); + +#ifndef _WIN32 + static bool fileExists(const std::string& filePath) + { + return access(filePath.c_str(), F_OK) != -1; + } + + template <size_t N> + static ssize_t readlink_safe(const char *pathname, char (&output)[N]) { + auto len = readlink(pathname, output, N - 1); + if (len > 0) { + output[len] = '\0'; + } + return len; + } + + static std::pair<ssize_t, std::string> + readlink_as_string(const char *pathname) { + char buf[2048] = {}; + auto len = readlink_safe(pathname, buf); + if (len <= 0) { + return {len, {}}; + } + return {len, std::string{buf, static_cast<size_t>(len)}}; + } + static std::string readlink_deep(const char *pathname) { + std::string prev{pathname}; + ssize_t len = 0; + std::string next; + while (true) { + std::tie(len, next) = readlink_as_string(prev.c_str()); + if (!next.empty()) { + prev = next; + } else { + return prev; + } + } + } + + static std::string drop_path_components(const std::string & path, size_t num_components) { + size_t pos = std::string::npos; + size_t slash_pos = std::string::npos; + for (size_t i = 0; i < num_components; ++i) { + slash_pos = path.find_last_of('/', pos); + if (slash_pos == std::string::npos || slash_pos == 0) { + return {}; + } + pos = slash_pos - 1; + } + return std::string{path.c_str(), slash_pos}; + } +#endif + static std::string detectJvmPath() + { + std::string result; + +#ifdef _WIN32 + + BYTE buffer[1024]; + DWORD size = sizeof(buffer); + HKEY versionKey; + + // Search via registry entries. + if (::RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\JavaSoft\\Java Runtime Environment\\", &versionKey) == ERROR_SUCCESS) + { + if (::RegQueryValueEx(versionKey, "CurrentVersion", NULL, NULL, buffer, &size) == ERROR_SUCCESS) + { + HKEY libKey; + + std::string keyName = std::string("Software\\JavaSoft\\Java Runtime Environment\\") + (const char*)buffer; + + ::RegCloseKey(versionKey); + + if (::RegOpenKeyA(HKEY_LOCAL_MACHINE, keyName.c_str(), &libKey) == ERROR_SUCCESS) + { + size = sizeof(buffer); + + if (::RegQueryValueEx(libKey, "RuntimeLib", NULL, NULL, buffer, &size) == ERROR_SUCCESS) + { + result = (const char*)buffer; + } + + ::RegCloseKey(libKey); + } + } + } + + if (result.length() == 0) + { + // Could not locate via registry. Try the JAVA_HOME environment variable. + if ((size = ::GetEnvironmentVariableA("JAVA_HOME", (LPSTR) buffer, sizeof(buffer))) != 0) + { + std::string javaHome((const char*) buffer, size); + + // Different installers put in different relative locations. + std::string options[] = { + javaHome + "\\jre\\bin\\client\\jvm.dll", + javaHome + "\\jre\\bin\\server\\jvm.dll", + javaHome + "\\bin\\client\\jvm.dll", + javaHome + "\\bin\\server\\jvm.dll" + }; + + for (auto const& i : options) + if (fileExists(i)) + return i; + } + } + +#else + + const char* javaHome = getenv("JAVA_HOME"); + if (javaHome != nullptr) { + #ifdef __APPLE__ + std::string libJvmPath = std::string(javaHome) + "/jre/lib/server/libjvm.dylib"; + #else + std::string libJvmPath = std::string(javaHome) + "/jre/lib/amd64/server/libjvm.so"; + #endif + result = libJvmPath; + } else { + std::string path = readlink_deep("/usr/bin/java"); + if (!path.empty()) { + // drop bin and java + auto javaHome = drop_path_components(path, 2); + if (!javaHome.empty()) { + std::string options[] = { + javaHome + "/jre/lib/amd64/server/libjvm.so", + javaHome + "/jre/lib/amd64/client/libjvm.so", + javaHome + "/jre/lib/server/libjvm.so", + javaHome + "/jre/lib/client/libjvm.so", + javaHome + "/lib/server/libjvm.so", + javaHome + "/lib/client/libjvm.so", + }; + + for (auto const &i : options) { + fprintf(stderr, "trying %s\n", i.c_str()); + if (fileExists(i)) { + return i; + } + } + } + } + // Best guess so far. + result = "/usr/lib/jvm/default-java/jre/lib/amd64/server/libjvm.so"; + } + +#endif // _WIN32 + + return result; + } + + Vm::Vm(const char* path_) + { + bool expected = false; + + std::string path = path_ ? path_ : detectJvmPath(); + + if (path.length() == 0) + throw InitializationException("Could not locate Java Virtual Machine"); + if (!isVm.compare_exchange_strong(expected, true)) + throw InitializationException("Java Virtual Machine already initialized"); + + if (javaVm == nullptr) + { + JNIEnv* env; + JavaVMInitArgs args = {}; + args.version = JNI_VERSION_1_2; + +#ifdef _WIN32 + + HMODULE lib = ::LoadLibraryA(path.c_str()); + + if (lib == NULL) + { + isVm.store(false); + throw InitializationException("Could not load JVM library"); + } + + CreateVm_t JNI_CreateJavaVM = (CreateVm_t) ::GetProcAddress(lib, "JNI_CreateJavaVM"); + + /** + Is your debugger catching an error here? This is normal. Just continue. The JVM + intentionally does this to test how the OS handles memory-reference exceptions. + */ + if (JNI_CreateJavaVM == NULL || JNI_CreateJavaVM(&javaVm, (void**) &env, &args) != 0) + { + isVm.store(false); + ::FreeLibrary(lib); + throw InitializationException("Java Virtual Machine failed during creation"); + } + +#else + + void* lib = ::dlopen(path.c_str(), RTLD_NOW | RTLD_GLOBAL); + + if (lib == NULL) + { + isVm.store(false); + throw InitializationException("Could not load JVM library"); + } + + CreateVm_t JNI_CreateJavaVM = (CreateVm_t) ::dlsym(lib, "JNI_CreateJavaVM"); + + if (JNI_CreateJavaVM == NULL || JNI_CreateJavaVM(&javaVm, (void**) &env, &args) != 0) + { + isVm.store(false); + ::dlclose(lib); + throw InitializationException("Java Virtual Machine failed during creation"); + } + +#endif // _WIN32 + } + } + + Vm::~Vm() + { + /* + Note that you can't ever *really* unload the JavaVM. If you call + DestroyJavaVM(), you can't then call JNI_CreateJavaVM() again. + So, instead we just flag it as "gone". + */ + isVm.store(false); + } + + // Forward Declarations + JNIEnv* env(); + +#ifndef _WIN32 + extern std::vector<jchar> toJString(const wchar_t* str, size_t length); +#endif + + namespace internal + { + // Base Type Conversions + void valueArg(value_t* v, bool a) { ((jvalue*) v)->z = jboolean(a); } + void valueArg(value_t* v, byte_t a) { ((jvalue*) v)->b = a; } + void valueArg(value_t* v, wchar_t a) { ((jvalue*) v)->c = jchar(a); } // Note: Possible truncation. + void valueArg(value_t* v, short a) { ((jvalue*) v)->s = a; } + void valueArg(value_t* v, int a) { ((jvalue*) v)->i = a; } + void valueArg(value_t* v, long long a) { ((jvalue*) v)->j = a; } + void valueArg(value_t* v, float a) { ((jvalue*) v)->f = a; } + void valueArg(value_t* v, double a) { ((jvalue*) v)->d = a; } + void valueArg(value_t* v, jobject a) { ((jvalue*) v)->l = a; } + void valueArg(value_t* v, const Object& a) { ((jvalue*) v)->l = a.getHandle(); } + void valueArg(value_t* v, const Object* const& a) { ((jvalue*) v)->l = a ? a->getHandle() : nullptr; } + + /* + Object Implementations + */ + + std::string valueSig(const Object* obj) + { + if (obj == nullptr || obj->isNull()) + return "Ljava/lang/Object;"; // One can always hope... + + std::string name = Class(obj->getClass(), Object::Temporary).getName(); + + // Change from "java.lang.Object" format to "java/lang/Object"; + for (size_t i = 0; i < name.length(); ++i) + if (name[i] == '.') + name[i] = '/'; + + return "L" + name + ";"; + } + + /* + String Implementations + */ + + void valueArg(value_t* v, const std::string& a) + { + ((jvalue*) v)->l = env()->NewStringUTF(a.c_str()); + } + + template <> void cleanupArg<std::string>(value_t* v) + { + env()->DeleteLocalRef(((jvalue*) v)->l); + } + + void valueArg(value_t* v, const char* a) + { + ((jvalue*) v)->l = env()->NewStringUTF(a); + } + + void valueArg(value_t* v, std::nullptr_t) + { + ((jvalue*) v)->l = nullptr; + } + + template <> void cleanupArg<const char*>(value_t* v) + { + env()->DeleteLocalRef(((jvalue*) v)->l); + } +#ifdef _WIN32 + + void valueArg(value_t* v, const std::wstring& a) + { + ((jvalue*) v)->l = env()->NewString((const jchar*) a.c_str(), jsize(a.length())); + } + + void valueArg(value_t* v, const wchar_t* a) + { + ((jvalue*) v)->l = env()->NewString((const jchar*) a, jsize(std::wcslen(a))); + } +#else + + void valueArg(value_t* v, const std::wstring& a) + { + auto jstr = toJString(a.c_str(), a.length()); + ((jvalue*) v)->l = env()->NewString(jstr.data(), jsize(jstr.size())); + } + + void valueArg(value_t* v, const wchar_t* a) + { + auto jstr = toJString(a, std::wcslen(a)); + ((jvalue*) v)->l = env()->NewString(jstr.data(), jsize(jstr.size())); + } + +#endif + + template <> void cleanupArg<const std::wstring*>(value_t* v) + { + env()->DeleteLocalRef(((jvalue*) v)->l); + } + + template <> void cleanupArg<const wchar_t*>(value_t* v) + { + env()->DeleteLocalRef(((jvalue*) v)->l); + } + + long getArrayLength(jarray array) + { + return env()->GetArrayLength(array); + } + } +} + diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/jnipp.h b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/jnipp.h new file mode 100644 index 0000000..0cda2dd --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/jnipp.h @@ -0,0 +1,1110 @@ +#ifndef _JNIPP_H_ +#define _JNIPP_H_ 1 + +// Standard Dependencies +#include <cstring> +#include <stdexcept> // For std::runtime_error +#include <string> + +// Forward Declarations +struct JNIEnv_; +struct _JNIEnv; +struct JavaVM_; +struct _JavaVM; +struct _jmethodID; +struct _jfieldID; +class _jobject; +class _jclass; +class _jarray; + +namespace jni +{ + // JNI Base Types +#ifdef __ANDROID__ + typedef _JNIEnv JNIEnv; + typedef _JavaVM JavaVM; +#else + typedef JNIEnv_ JNIEnv; + typedef JavaVM_ JavaVM; +#endif + + typedef _jobject* jobject; + typedef _jclass* jclass; + typedef _jarray* jarray; + + /** + You can save a method via its handle using Class::getMethod() if it is + going to be used often. This saves Object::call() from having to locate + the method each time by name. + + Note that these handles are global and do not need to be deleted. + */ + typedef _jmethodID* method_t; + + /** + You can save a field via its handle using Class::getField() if it is + going to be used often. This saves Object::set() and Object::get() from + having to locate the field each time by name. + + Note that these handles are global and do not need to be deleted. + */ + typedef _jfieldID* field_t; + + /** + Type used to denote the Java byte type. + */ + typedef unsigned char byte_t; + +#ifdef JNIPP_EXCEPTION_CLASS + + /** + Base class for thrown Exceptions. + */ + typedef JNIPP_EXCEPTION_CLASS Exception; + +#else + + /** + Base class for thrown Exceptions. + */ + typedef std::runtime_error Exception; + +#endif // JNIPP_EXCEPTION_CLASS + + // Foward Declarations + class Object; + template <class TElement> class Array; + + /** + This namespace is for messy implementation details only. It is not a part + of the external API and is subject to change at any time. It is only in a + header file due to the fact it is required by some template functions. + + Long story short... this stuff be messy, yo. + */ + namespace internal + { + /* + Signature Generation + */ + + inline std::string valueSig(const void*) { return "V"; } + inline std::string valueSig(const bool*) { return "Z"; } + inline std::string valueSig(const byte_t*) { return "B"; } + inline std::string valueSig(const wchar_t*) { return "C"; } + inline std::string valueSig(const short*) { return "S"; } + inline std::string valueSig(const int*) { return "I"; } + inline std::string valueSig(const long long*) { return "J"; } + inline std::string valueSig(const float*) { return "F"; } + inline std::string valueSig(const double*) { return "D"; } + inline std::string valueSig(const std::string*) { return "Ljava/lang/String;"; } + inline std::string valueSig(const std::wstring*) { return "Ljava/lang/String;"; } + inline std::string valueSig(const char* const*) { return "Ljava/lang/String;"; } + inline std::string valueSig(const wchar_t* const*) { return "Ljava/lang/String;"; } + std::string valueSig(const Object* obj); + inline std::string valueSig(const Object* const* obj) { return valueSig(obj ? *obj : nullptr); } + + template <class TArg> + inline std::string valueSig(const Array<TArg>*) { return "[" + valueSig((TArg*) nullptr); } + + template <int n, class TArg> + inline std::string valueSig(const TArg(*arg)[n]) { return valueSig((const TArg* const*)arg); } + + inline std::string sig() { return ""; } + + template <class TArg, class... TArgs> + std::string sig(const TArg& arg, const TArgs&... args) { + return valueSig(&arg) + sig(args...); + } + + /* + Argument Conversion + */ + + typedef long long value_t; + + void valueArg(value_t* v, bool a); + void valueArg(value_t* v, byte_t a); + void valueArg(value_t* v, wchar_t a); + void valueArg(value_t* v, short a); + void valueArg(value_t* v, int a); + void valueArg(value_t* v, long long a); + void valueArg(value_t* v, float a); + void valueArg(value_t* v, double a); + void valueArg(value_t* v, jobject a); + void valueArg(value_t* v, const Object& a); + void valueArg(value_t* v, const Object* const& a); + void valueArg(value_t* v, const std::string& a); + void valueArg(value_t* v, const char* a); + void valueArg(value_t* v, const std::wstring& a); + void valueArg(value_t* v, const wchar_t* a); + void valueArg(value_t* v, std::nullptr_t); + + inline void args(value_t*) {} + + template <class TArg, class... TArgs> + void args(value_t* values, const TArg& arg, const TArgs&... args) { + valueArg(values, arg); + internal::args(values + 1, args...); + } + + template <class TArg> void cleanupArg(value_t* /* value */) {} + template <> void cleanupArg<std::string>(value_t* value); + template <> void cleanupArg<std::wstring>(value_t* value); + template <> void cleanupArg<const char*>(value_t* value); + template <> void cleanupArg<const wchar_t*>(value_t* value); + + template <class TArg = void, class... TArgs> + void cleanupArgs(value_t* values) { + cleanupArg<TArg>(values); + cleanupArgs<TArgs...>(values + 1); + } + + template <> + inline void cleanupArgs<void>(value_t* /* values */) {} + + template <class... TArgs> + class ArgArray + { + public: + ArgArray(const TArgs&... args) { + std::memset(this, 0, sizeof(ArgArray<TArgs...>)); + internal::args(values, args...); + } + + ~ArgArray() { + cleanupArgs<TArgs...>(values); + } + + value_t values[sizeof...(TArgs)]; + }; + + /* specialization for empty array - no args. Avoids "empty array" warning. */ + template <> + class ArgArray<> + { + public: + ArgArray() { + std::memset(this, 0, sizeof(ArgArray<>)); + } + + ~ArgArray() { + } + + value_t values[1]; + }; + long getArrayLength(jarray array); + + /** + * @brief Used as a tag type for dispatching internally based on return type. + * + * @tparam T The type to wrap. + */ + template<typename T> + struct ReturnTypeWrapper + { + using type = T; + }; + } + + /** + Initialises the Java Native Interface with the given JNIEnv handle, which + gets passed into a native function which is called from Java. This only + needs to be done once per process - further calls are no-ops. + \param env A JNI environment handle. + */ + void init(JNIEnv* env); + /** + Initialises the Java Native Interface with the given JavaVM handle, + which may be accessible. This (or the other overload) only needs to be + done once per process - further calls are no-ops. + \param vm A JNI VM handle. + */ + void init(JavaVM* vm); + + /** + Get the appropriate JNI environment for this thread. + */ + JNIEnv* env(); + + /** + Object corresponds with a `java.lang.Object` instance. With an Object, + you can then call Java methods, and access fields on the Object. To + instantiate an Object of a given class, use the `Class` class. + */ + class Object + { + public: + /** Flags which can be passed to the Object constructor. */ + enum ScopeFlags + { + Temporary = 1, ///< Temporary object. Do not create a global reference. + DeleteLocalInput = 2 ///< The input reference is temporary and can be deleted. + }; + + /** Default constructor. Creates a `null` object. */ + Object() noexcept; + + /** + Copies a reference to another Object. Note that this is not a deep + copy operation, and both Objects will reference the same Java + Object. + \param other The Object to copy. + */ + Object(const Object& other); + + /** + Move constructor. Copies the Object reference from the supplied + Object, and then nulls the supplied Object reference. + \param other The Object to move. + */ + Object(Object&& other) noexcept; + + /** + Creates an Object from a local JNI reference. + \param ref The local JNI reference. + \param scopeFlags Bitmask of ScopeFlags values. + */ + Object(jobject ref, int scopeFlags = 0); + + /** + Destructor. Releases this reference on the Java Object so it can be + picked up by the garbage collector. + */ + virtual ~Object() noexcept; + + /** + Assignment operator. Copies the object reference from the supplied + Object. They will now both point to the same Java Object. + \param other The Object to copy. + \return This Object. + */ + Object& operator=(const Object& other); + + /** + Assignment operator. Moves the object reference from the supplied + Object to this one, and leaves the other one as a null. + \param other The Object to move. + \return This Object. + */ + Object& operator=(Object&& other); + + /** + Tells whether the two Objects refer to the same Java Object. + \param other the Object to compare with. + \return `true` if the same, `false` otherwise. + */ + bool operator==(const Object& other) const; + + /** + Tells whether the two Objects refer to the same Java Object. + \param other the Object to compare with. + \return `true` if the different, `false` otherwise. + */ + bool operator!=(const Object& other) const { return !operator==(other); } + + /** + Calls the given method on this Object. The method should have no + parameters. Note that the return type should be explicitly stated + in the function call. + \param method A method handle which applies to this Object. + \return The method's return value. + */ + template <class TReturn> + TReturn call(method_t method) const { return callMethod(method, nullptr, internal::ReturnTypeWrapper<TReturn>{}); } + + /** + Calls the method on this Object with the given name, and no arguments. + Note that the return type should be explicitly stated in the function + call. + \param name The name of the method to call (with optional signature). + \return The method's return value. + */ + template <class TReturn> + TReturn call(const char* name) const { + if (std::strstr(name, "()")) + return call<TReturn>(getMethod(name)); + + // No signature supplied. Generate our own. + method_t method = getMethod(name, ("()" + internal::valueSig((TReturn*) nullptr)).c_str()); + return call<TReturn>(method); + } + + /** + Calls the method on this Object and supplies the given arguments. + Note that the return type should be explicitly stated in the function + call. + \param method The method to call. + \param args Arguments to supply to the method. + \return The method's return value. + */ + template <class TReturn, class... TArgs> + TReturn call(method_t method, const TArgs&... args) const { + internal::ArgArray<TArgs...> transform(args...); + return callMethod(method, transform.values, internal::ReturnTypeWrapper<TReturn>{}); + } + + /** + Calls the method on this Object and supplies the given arguments. + Note that the return type should be explicitly stated in the function + call. The type signature of the method is calculated by the types of + the supplied arguments. + \param name The name of the method to call (and optional signature). + \param args Arguments to supply to the method. + \return The method's return value. + */ + template <class TReturn, class... TArgs> + TReturn call(const char* name, const TArgs&... args) const { + if (std::strchr(name, '(')) + return call<TReturn>(getMethod(name), args...); + + std::string sig = "(" + internal::sig(args...) + ")" + internal::valueSig((TReturn*) nullptr); + method_t method = getMethod(name, sig.c_str()); + return call<TReturn>(method, args...); + } + + /** + Gets a field value from this Object. The field must belong to the + Object's class. Note that the field type should be explicitly stated + in the function call. + \param field Identifier for the field to retrieve. + \return The field's value. + */ + template <class TType> + TType get(field_t field) const { + // If you get a compile error here, then you've asked for a type + // we don't know how to get from JNI directly. + return getFieldValue(field, internal::ReturnTypeWrapper<TType>{}); + } + + /** + Gets a field value from this Object. The field must belong to the + Object's class. Note that the field type should be explicitly stated + in the function call. + \param name The name of the field to retrieve. + \return The field's value. + */ + template <class TType> + TType get(const char* name) const { + field_t field = getField(name, internal::valueSig((TType*) nullptr).c_str()); + return get<TType>(field); + } + + /** + Sets a field's value on this Object. The field must belong to the + Object's class, and the parameter's type should correspond to the + type of the field. + \param field The field to set the value to. + \param value The value to set. + */ + template <class TType> + void set(field_t field, const TType& value); + + /** + Sets a field's value on this Object. The field must belong to the + Object's class, and the parameter's type should correspond to the + type of the field. + \param name The name of the field to set the value to. + \param value The value to set. + */ + template <class TType> + void set(const char* name, const TType& value) { + field_t field = getField(name, internal::valueSig((TType*) nullptr).c_str()); + set(field, value); + } + + /** + Tells whether this Object is currently a `null` pointer. + \return `true` if `null`, `false` if it references an object. + */ + bool isNull() const noexcept; + + /** + Gets a handle for this Object's class. Ideally, this should just return a Class, + but C++ won't let us do that that. + \return The Object's Class's handle. + */ + jclass getClass() const; + + /** + Gets the underlying JNI jobject handle. + \return The JNI handle. + */ + jobject getHandle() const noexcept { return _handle; } + + /** + Create a local reference for the underlying JNI handle. + \return The local reference. + */ + jobject makeLocalReference() const; + + private: + // Helper Functions + method_t getMethod(const char* name, const char* signature) const; + method_t getMethod(const char* nameAndSignature) const; + field_t getField(const char* name, const char* signature) const; + + void callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<void> const&) const; + bool callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<bool> const&) const; + byte_t callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<byte_t> const&) const; + wchar_t callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<wchar_t> const&) const; + short callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<short> const&) const; + int callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<int> const&) const; + long long callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<long long> const&) const; + float callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<float> const&) const; + double callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<double> const&) const; + std::string callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<std::string> const&) const; + std::wstring callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<std::wstring> const&) const; + jni::Object callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<jni::Object> const&) const; + jarray callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<jarray> const&) const; + + template<typename T> + jni::Array<T> callMethod(method_t method, internal::value_t* args, internal::ReturnTypeWrapper<jni::Array<T>> const&) const; + + void getFieldValue(field_t field, internal::ReturnTypeWrapper<void> const&) const; + bool getFieldValue(field_t field, internal::ReturnTypeWrapper<bool> const&) const; + byte_t getFieldValue(field_t field, internal::ReturnTypeWrapper<byte_t> const&) const; + wchar_t getFieldValue(field_t field, internal::ReturnTypeWrapper<wchar_t> const&) const; + short getFieldValue(field_t field, internal::ReturnTypeWrapper<short> const&) const; + int getFieldValue(field_t field, internal::ReturnTypeWrapper<int> const&) const; + long long getFieldValue(field_t field, internal::ReturnTypeWrapper<long long> const&) const; + float getFieldValue(field_t field, internal::ReturnTypeWrapper<float> const&) const; + double getFieldValue(field_t field, internal::ReturnTypeWrapper<double> const&) const; + std::string getFieldValue(field_t field, internal::ReturnTypeWrapper<std::string> const&) const; + std::wstring getFieldValue(field_t field, internal::ReturnTypeWrapper<std::wstring> const&) const; + jni::Object getFieldValue(field_t field, internal::ReturnTypeWrapper<jni::Object> const&) const; + + // Instance Variables + jobject _handle; + mutable jclass _class; + bool _isGlobal; + }; + + /** + Class corresponds with `java.lang.Class`, and allows you to instantiate + Objects and get class members such as methods and fields. + */ + class Class : protected Object + { + public: + /** + Creates a null class reference. + */ + Class() : Object() {} + + /** + Obtains a class reference to the Java class with the given qualified + name. + \param name The qualified class name (e.g. "java/lang/String"). + */ + Class(const char* name); + + /** + Creates a Class object by JNI reference. + \param ref The JNI class reference. + \param scopeFlags Bitmask of Object::ScopeFlags. + */ + Class(jclass ref, int scopeFlags = Temporary); + + /** + Tells whether this Class is null or valid. + \return `true` if null, `false` if valid. + */ + bool isNull() const noexcept { return Object::isNull(); } + + /** + Creates a new instance of this Java class and returns a reference to + it. The item's parameterless constructor is called. + \return The created instance. + */ + Object newInstance() const; + + /** + Creates a new instance of this Java class and returns a reference to + it. + \param constructor The constructor to call. + \param args Arguments to supply to the constructor. + \return The created instance. + */ + template <class... TArgs> + Object newInstance(method_t constructor, const TArgs&... args) const { + internal::ArgArray<TArgs...> transform(args...); + return newObject(constructor, transform.values); + } + + /** + Creates a new instance of this Java class and returns a reference to + it. The constructor signature is determined by the supplied parameters, + and the parameters are then passed to the constructor. + \param args Arguments to supply to the constructor. + \return The created instance. + */ + template <class... TArgs> + Object newInstance(const TArgs&... args) const { + method_t constructor = getMethod("<init>", ("(" + internal::sig(args...) + ")V").c_str()); + return newInstance(constructor, args...); + } + + /** + Gets a handle to the field with the given name and type signature. + This handle can then be stored so that the field does not need to + be looked up by name again. It does not need to be deleted. + \param name The name of the field. + \param signature The JNI type signature of the field. + \return The field ID. + */ + field_t getField(const char* name, const char* signature) const; + + /** + Gets a handle to the field with the given name and the supplied type. + This handle can then be stored so that the field does not need to + be looked up by name again. It does not need to be deleted. + \param name The name of the field. + \return The field ID. + */ + template<typename TType> + field_t getField(const char* name) const { + return getField(name, internal::valueSig((TType*) nullptr).c_str()); + } + + /** + Gets a handle to the static field with the given name and type signature. + This handle can then be stored so that the field does not need to + be looked up by name again. It does not need to be deleted. + \param name The name of the field. + \param signature The JNI type signature of the field. + \return The field ID. + */ + field_t getStaticField(const char* name, const char* signature) const; + + /** + Gets a handle to the static field with the given name and the supplied type. + This handle can then be stored so that the field does not need to + be looked up by name again. It does not need to be deleted. + \param name The name of the field. + \return The field ID. + */ + template<typename TType> + field_t getStaticField(const char* name) const { + return getStaticField(name, internal::valueSig((TType*)nullptr).c_str()); + } + + /** + Gets a handle to the method with the given name and signature. + This handle can then be stored so that the method does not need + to be looked up by name again. It does not need to be deleted. + \param name The name of the method. + \param signature The JNI method signature. + \return The method ID. + */ + method_t getMethod(const char* name, const char* signature) const; + + /** + Gets a handle to the method with the given name and signature. + This handle can then be stored so that the method does not need + to be looked up by name again. It does not need to be deleted. + \param nameAndSignature Name and signature identifier (e.g. "toString()Ljava/lang/String;"). + \return The method ID. + */ + method_t getMethod(const char* nameAndSignature) const; + + /** + Gets a handle to the static method with the given name and signature. + This handle can then be stored so that the method does not need + to be looked up by name again. It does not need to be deleted. + \param name The name of the method. + \param signature The JNI method signature. + \return The method ID. + */ + method_t getStaticMethod(const char* name, const char* signature) const; + + /** + Gets a handle to the static method with the given name and signature. + This handle can then be stored so that the method does not need + to be looked up by name again. It does not need to be deleted. + \param nameAndSignature Name and signature identifier (e.g. "toString()Ljava/lang/String;"). + \return The method ID. + */ + method_t getStaticMethod(const char* nameAndSignature) const; + + /** + Gets a handle to the constructor for this Class with the given + signature. Note that the return type should always be `void` ("V"). + \param signature The JNI method signature for the constructor. + \return The constructor method ID. + */ + method_t getConstructor(const char* signature) const { return getMethod("<init>", signature); } + + /** + Gets the parent Class of this Class. + \return The parent class. + */ + Class getParent() const; + + /** + Gets the JNI-qualified name of this Class. + \return The Class name. + */ + std::string getName() const; + + /** + Calls a static method on this Class. The method should have no + parameters. Note that the return type should be explicitly stated + in the function call. + \param method A method handle which applies to this Object. + \return The method's return value. + */ + template <class TReturn> + TReturn call(method_t method) const { return callStaticMethod<TReturn>(method, nullptr); } + + /** + Calls a static method on this Class with the given name, and no arguments. + Note that the return type should be explicitly stated in the function + call. + \param name The name of the method to call. + \return The method's return value. + */ + template <class TReturn> + TReturn call(const char* name) const { + method_t method = getStaticMethod(name, ("()" + internal::valueSig((TReturn*) nullptr)).c_str()); + return call<TReturn>(method); + } + + /** + Calls a static method on this Class and supplies the given arguments. + Note that the return type should be explicitly stated in the function + call. + \param method The method to call. + \param args Arguments to supply to the method. + \return The method's return value. + */ + template <class TReturn, class... TArgs> + TReturn call(method_t method, const TArgs&... args) const { + internal::ArgArray<TArgs...> transform(args...); + return callStaticMethod<TReturn>(method, transform.values); + } + + /** + Calls a static method on this Class and supplies the given arguments. + Note that the return type should be explicitly stated in the function + call. The type signature of the method is calculated by the types of + the supplied arguments. + \param name The name of the method to call. + \param args Arguments to supply to the method. + \return The method's return value. + */ + template <class TReturn, class... TArgs> + TReturn call(const char* name, const TArgs&... args) const { + if (std::strchr(name, '(')) + return call<TReturn>(getStaticMethod(name), args...); + + std::string sig = "(" + internal::sig(args...) + ")" + internal::valueSig((TReturn*) nullptr); + method_t method = getStaticMethod(name, sig.c_str()); + return call<TReturn>(method, args...); + } + + /** + Calls a non-static method on this Class, applying it to the supplied + Object. The difference between this and Object.call() is that the + specific class implementation of the method is called, rather than + doing a virtual method lookup. + \param obj The Object to call the method on. + \param method The method to call. + \return The method's return value. + */ + template <class TReturn> + TReturn call(const Object& obj, method_t method) const { + return callExactMethod<TReturn>(obj.getHandle(), method, nullptr); + } + + /** + Calls a non-static method on this Class, applying it to the supplied + Object. The difference between this and Object.call() is that the + specific class implementation of the method is called, rather than + doing a virtual method lookup. + \param obj The Object to call the method on. + \param name The name of the method to call. + \return The method's return value. + */ + template <class TReturn> + TReturn call(const Object& obj, const char* name) const { + method_t method = getMethod(name, ("()" + internal::valueSig((TReturn*) nullptr)).c_str()); + return call<TReturn>(obj, method); + } + template <class TReturn> + TReturn call(const Object* obj, const char* name) const { + return call<TReturn>(obj, name); + } + + /** + Calls a non-static method on this Class, applying it to the supplied + Object. The difference between this and Object.call() is that the + specific class implementation of the method is called, rather than + doing a virtual method lookup. + \param obj The Object to call the method on. + \param method The method to call. + \param args Arguments to pass to the method. + \return The method's return value. + */ + template <class TReturn, class... TArgs> + TReturn call(const Object& obj, method_t method, const TArgs&... args) const { + internal::ArgArray<TArgs...> transform(args...); + return callExactMethod<TReturn>(obj.getHandle(), method, transform.values); + } + template <class TReturn, class... TArgs> + TReturn call(const Object* obj, method_t method, const TArgs&... args) const { + return call<TReturn>(*obj, method, args...); + } + + /** + Calls a non-static method on this Class, applying it to the supplied + Object. The difference between this and Object.call() is that the + specific class implementation of the method is called, rather than + doing a virtual method lookup. + \param obj The Object to call the method on. + \param name The name of the method to call. + \param args Arguments to pass to the method. + \return The method's return value. + */ + template <class TReturn, class... TArgs> + TReturn call(const Object& obj, const char* name, const TArgs&... args) const { + std::string sig = "(" + internal::sig(args...) + ")" + internal::valueSig((TReturn*) nullptr); + method_t method = getMethod(name, sig.c_str()); + return call<TReturn>(obj, method, args...); + } + template <class TReturn, class... TArgs> + TReturn call(const Object* obj, const char* name, const TArgs&... args) const { + return call<TReturn>(*obj, name, args...); + } + + /** + Gets a static field value from this Class. Note that the field type + should be explicitly stated in the function call. + \param field Identifier for the field to retrieve. + \return The field's value. + */ + template <class TType> + TType get(field_t field) const; + + /** + Gets a static field value from this Class. Note that the field type + should be explicitly stated in the function call. + \param name The name of the field to retrieve. + \return The field's value. + */ + template <class TType> + TType get(const char* name) const { + field_t field = getStaticField(name, internal::valueSig((TType*) nullptr).c_str()); + return get<TType>(field); + } + + /** + Sets a static field's value on this Class. The parameter's type should + correspond to the type of the field. + \param field The field to set the value to. + \param value The value to set. + */ + template <class TType> + void set(field_t field, const TType& value); + + /** + Sets a static field's value on this Class. The parameter's type + should correspond to the type of the field. + \param name The name of the field to set the value to. + \param value The value to set. + */ + template <class TType> + void set(const char* name, const TType& value) { + field_t field = getStaticField(name, internal::valueSig((TType*) nullptr).c_str()); + set(field, value); + } + + /** + Gets the underlying JNI jclass handle. + \return The JNI handle. + */ + jclass getHandle() const noexcept { return jclass(Object::getHandle()); } + + private: + // Helper Functions + template <class TType> TType callStaticMethod(method_t method, internal::value_t* values) const; + template <class TType> TType callExactMethod(jobject obj, method_t method, internal::value_t* values) const; + Object newObject(method_t constructor, internal::value_t* args) const; + }; + + /** + Convenience class for dealing with Java enums. + */ + class Enum : protected Class + { + public: + /** + Loads the Enum with the given JNI-formatted name. + \param name The name of the enum. + */ + Enum(const char* name); + + /** + Gets the enum value with the given name. + \param name The name of the enum value. + \return The enum value identifier. + */ + Object get(const char* name) const; + + private: + // Instance Variables + std::string _name; + }; + + /** + Used to interact with native Java arrays. The element type can be any primitive + type, jni::Object, std::string or std::wstring. + */ + template <class TElement> + class Array : public Object + { + public: + /** + Default constructor. Creates a null array reference. + */ + Array() noexcept; + + /** + Creates a Array object by JNI reference. + \param ref The JNI array reference. + \param scopeFlags Bitmask of Object::ScopeFlags. + */ + Array(jarray ref, int scopeFlags = Temporary); + + /** + Creates an Array of the given length. The elements are default initialised + to zero / null values. + \param length The Array length. + */ + Array(long length); + + /** + Creates an Array of the given length. A Class type is also specified, but can + be left null to default to "java.lang.Object". + \param length The Array length. + \param type The element type. + + */ + Array(long length, const Class& type); + + /** + Copy constructor. Shares a reference to the Java array with the + copied Array object. + \param other The Array to copy. + */ + Array(const Array<TElement>& other); + + /** + Move constructor. Moves the array reference to the new Array, and leaves + the previous Array as a null reference. + \param other The Array to move. + */ + Array(Array<TElement>&& other) noexcept; + + /** + Assignment operator. Copies the array reference from the supplied + Array. They will now both point to the same Java array. + \param other The Array to copy. + \return This Array. + */ + Array<TElement>& operator=(const Array<TElement>& other); + + /** + Assignment operator. Moves the array reference from the supplied + Array to this one, and leaves the other one as a null. + \param other The Array to move. + \return This Array. + */ + Array<TElement>& operator=(Array<TElement>&& other); + + /** + Checks whether these Arrays both reference the same java array. + \param other The Array to compare with. + \return true if the same (or both null), false otherwise. + */ + bool operator==(const Array<TElement>& other) const { return Object::operator==(other); } + + /** + Checks whether these Arrays reference different the java arrays. + \param other The Array to compare with. + \return false if the same (or both null), true otherwise. + */ + bool operator!=(const Array<TElement>& other) const { return !operator==(other); } + + /** + Sets the element value at the given index in the Array. + \param index The zero-based index. + \param value The value to set. + */ + void setElement(long index, TElement value); + + /** + Gets the value at the given index within the Array. + \param index The zero-based index. + \return The element at the given index. + */ + TElement getElement(long index) const; + TElement operator[](long index) const { return getElement(index); } + + /** + Gets the length of this Array. + \return The array length. + */ + long getLength() const; + + /** + Gets the underlying JNI jarray handle. + \return The JNI handle. + */ + jarray getHandle() const noexcept { return jarray(Object::getHandle()); } + + private: + // Instance Variables + mutable long _length; ///< Mutable as it may only finally get set in a getLength() call. + }; + + /** + When the application's entry point is in C++ rather than in Java, it will + need to spin up its own instance of the Java Virtual Machine (JVM) before + it can initialize the Java Native Interface. Vm is used to create and + destroy a running JVM instance. + + It uses the RAII idiom, so when the destructor is called, the Vm is shut + down. + + Note that currently only one instance is supported. Attempts to create + more will result in an InitializationException. + */ + class Vm final + { + public: + /** + Starts the Java Virtual Machine. + \param path The path to the jvm.dll (or null for auto-detect). + */ + Vm(const char* path = nullptr); + + /** Destroys the running instance of the JVM. */ + ~Vm(); + }; + + /** + A Java method call threw an Exception. + */ + class InvocationException : public Exception + { + public: + /** + Constructor with an error message. + \param msg Message to pass to the Exception. + */ + InvocationException(const char* msg = "Java Exception detected") : Exception(msg) {} + }; + + /** + A supplied name or type signature could not be resolved. + */ + class NameResolutionException : public Exception + { + public: + /** + Constructor with an error message. + \param name The name of the unresolved symbol. + */ + NameResolutionException(const char* name) : Exception(name) {} + }; + + /** + The Java Native Interface was not properly initialized. + */ + class InitializationException : public Exception + { + public: + /** + Constructor with an error message. + \param msg Message to pass to the Exception. + */ + InitializationException(const char* msg) : Exception(msg) {} + }; + + /* + Call method returning array: implementation + */ + template <typename T> + inline jni::Array<T> Object::callMethod(method_t method, internal::value_t* args, + internal::ReturnTypeWrapper<jni::Array<T>> const&) const + { + jarray result = callMethod(method, args, internal::ReturnTypeWrapper<jarray>{}); + return jni::Array<T>(result, DeleteLocalInput); + } + + /* + Array Implementation + */ + + template <class TElement> + Array<TElement>::Array() noexcept : Object(), _length(0) + { + } + + template <class TElement> + Array<TElement>::Array(jarray ref, int scopeFlags) : Object((jobject) ref, scopeFlags), _length(-1) + { + } + + template <class TElement> + Array<TElement>::Array(const Array<TElement>& other) : Object(other), _length(other._length) + { + } + + template <class TElement> + Array<TElement>::Array(Array<TElement>&& other) noexcept : Object((Object&&)other), _length(other._length) + { + other._length = 0; + } + + template <class TElement> + Array<TElement>& Array<TElement>::operator=(const Array<TElement>& other) + { + if (&other != this) + { + Object::operator=(other); + _length = other._length; + } + + return *this; + } + + template <class TElement> + Array<TElement>& Array<TElement>::operator=(Array<TElement>&& other) + { + if (&other != this) + { + Object::operator=((Object&&) other); + _length = other._length; + + other._length = 0; + } + + return *this; + } + + template <class TElement> + long Array<TElement>::getLength() const + { + if (_length < 0) + { + _length = internal::getArrayLength(getHandle()); + } + + return _length; + } +} + +#endif // _JNIPP_H_ + diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/makefile b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/makefile new file mode 100644 index 0000000..f751afd --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/makefile @@ -0,0 +1,32 @@ +CC=g++ + +OS_NAME := linux + +ifeq ($(OS),Windows_NT) + OS_NAME := win32 + RM := del +else + RM := rm -f + UNAME_S := $(shell uname -s) + ifeq ($(UNAME_S),Darwin) + OS_NAME := darwin + endif +endif + +JAVA_HOME ?= /usr/lib/jvm/default-java + +CXXFLAGS=-I. -I$(JAVA_HOME)/include -I$(JAVA_HOME)/include/$(OS_NAME) -ldl -std=c++11 -Wall -g + +SRC=jnipp.o main.o +VPATH=tests + +%.o: %.cpp + $(CC) -c -o $@ $< $(CXXFLAGS) + +test: $(SRC) + $(CC) -o test $(SRC) $(CXXFLAGS) + +clean: + -$(RM) $(SRC) test + +.PHONY: clean diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/tests/CMakeLists.txt b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/tests/CMakeLists.txt new file mode 100644 index 0000000..b17c12d --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/tests/CMakeLists.txt @@ -0,0 +1,18 @@ +# Copyright 2021, Collabora, Ltd. +# +# SPDX-License-Identifier: MIT + +add_executable(main_test main.cpp testing.h) +target_link_libraries(main_test PRIVATE jnipp) +add_test(NAME main_test COMMAND main_test) + +add_executable(external_create external_create.cpp testing.h) +target_link_libraries(external_create PUBLIC jnipp ${JNI_LIBRARIES}) +target_include_directories(external_create PUBLIC ${JNI_INCLUDE_DIRS}) +add_test(NAME external_create COMMAND external_create) + + +add_executable(external_detach external_detach.cpp testing.h) +target_link_libraries(external_detach PUBLIC jnipp ${JNI_LIBRARIES}) +target_include_directories(external_detach PUBLIC ${JNI_INCLUDE_DIRS}) +add_test(NAME external_detach COMMAND external_detach) diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/tests/external_create.cpp b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/tests/external_create.cpp new file mode 100644 index 0000000..735c248 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/tests/external_create.cpp @@ -0,0 +1,37 @@ +// Project Dependencies +#include <jni.h> +#include <jnipp.h> + +// Standard Dependencies +#include <cmath> + +// Local Dependencies +#include "testing.h" + +/* + jni::Vm Tests + */ +TEST(Vm_externalCreateAndAttach) { + JNIEnv *env; + JavaVMInitArgs args = {}; + args.version = JNI_VERSION_1_2; + JavaVM *javaVm{}; + auto ret = JNI_CreateJavaVM(&javaVm, (void **)&env, &args); + ASSERT(ret == 0); + + { + jni::init(env); + jni::Class cls("java/lang/String"); + } + JavaVM *localVmPointer{}; + + ret = env->GetJavaVM(&localVmPointer); + ASSERT(ret == 0); +} + +int main() { + // jni::Vm Tests + RUN_TEST(Vm_externalCreateAndAttach); + + return 0; +} diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/tests/external_detach.cpp b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/tests/external_detach.cpp new file mode 100644 index 0000000..dda0245 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/tests/external_detach.cpp @@ -0,0 +1,34 @@ +// Project Dependencies +#include <jni.h> +#include <jnipp.h> + +// Standard Dependencies +#include <cmath> + +// Local Dependencies +#include "testing.h" + +/* + jni::Vm Tests + */ +TEST(Vm_externalDetach) { + jni::Vm vm; + + jni::Class cls("java/lang/String"); + + JNIEnv *env = (JNIEnv *)jni::env(); + JavaVM *localVmPointer{}; + + auto ret = env->GetJavaVM(&localVmPointer); + ASSERT(ret == 0); + ret = localVmPointer->DetachCurrentThread(); + ASSERT(ret == 0); + + ASSERT(1); +} + +int main() { + // jni::Vm Tests + RUN_TEST(Vm_externalDetach); + return 0; +} diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/tests/main.cpp b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/tests/main.cpp new file mode 100644 index 0000000..d92e0bd --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/tests/main.cpp @@ -0,0 +1,651 @@ +// Project Dependencies +#include <jnipp.h> + +// Standard Dependencies +#include <cmath> + +// Local Dependencies +#include "testing.h" + +/* + jni::Vm Tests + */ + + +TEST(Vm_detectsJreInstall) +{ + try + { + jni::Vm vm; + } + catch (jni::InitializationException&) + { + ASSERT(0); + return; + } + + ASSERT(1); +} + +TEST(Vm_notAllowedMultipleVms) +{ + try + { + jni::Vm firstVm; + jni::Vm secondVm; // Throws an exception. + } + catch (jni::InitializationException&) + { + ASSERT(1); + return; + } + + ASSERT(0); +} + +/* + jni::Class Tests + */ + + +TEST(Class_findByName_success) +{ + jni::Class cls("java/lang/String"); + + ASSERT(!cls.isNull()); +} + +TEST(Class_findByName_failure) +{ + try + { + jni::Class cls("does/not/Exist"); + } + catch (jni::NameResolutionException&) + { + ASSERT(1); + return; + } + + ASSERT(0); +} + +TEST(Class_getName) +{ + jni::Class cls("java/lang/String"); + + ASSERT(cls.getName() == "java.lang.String"); +} + +TEST(Class_getParent) +{ + jni::Class parent = jni::Class("java/lang/Integer").getParent(); + + ASSERT(parent.getName() == "java.lang.Number"); +} + +TEST(Class_newInstance) +{ + jni::Class Integer("java/lang/Integer"); + jni::method_t constructor = Integer.getConstructor("(Ljava/lang/String;)V"); + jni::Object i = Integer.newInstance(constructor, "123"); + jni::Object str = jni::Class("java/lang/String").newInstance(); + + ASSERT(!i.isNull()); + ASSERT(!str.isNull()); +} + +TEST(Class_newInstance_withArgs) +{ + jni::Object str1 = jni::Class("java/lang/String").newInstance("Testing..."); + jni::Object str2 = jni::Class("java/lang/String").newInstance(L"Testing..."); + + ASSERT(!str1.isNull()); + ASSERT(!str2.isNull()); +} + +TEST(Class_getStaticField) +{ + jni::field_t field = jni::Class("java/lang/Integer").getStaticField("MAX_VALUE", "I"); + + ASSERT(field); +} + +TEST(Class_getMethod) +{ + jni::method_t method1 = jni::Class("java/lang/Integer").getMethod("intValue", "()I"); + jni::method_t method2 = jni::Class("java/lang/Integer").getMethod("intValue()I"); + + ASSERT(method1); + ASSERT(method2); +} + +TEST(Class_getStaticMethod) +{ + jni::method_t method = jni::Class("java/lang/Integer").getStaticMethod("compare", "(II)I"); + + ASSERT(method); +} + +TEST(Class_call) +{ + jni::Class Integer("java/lang/Math"); + + double x = Integer.call<double>("random"); + + ASSERT(x >= 0.0); + ASSERT(x < 1.0); +} + +TEST(Class_get_staticField) +{ + jni::Class Integer("java/lang/Integer"); + jni::field_t field = Integer.getStaticField("SIZE", "I"); + + ASSERT(Integer.get<int>(field) == 32); +} + +TEST(Class_get_staticField_byName) +{ + jni::Class Integer("java/lang/Integer"); + jni::Class Character("java/lang/Character"); + jni::Class Short("java/lang/Short"); + jni::Class Long("java/lang/Long"); + jni::Class Float("java/lang/Float"); + jni::Class Double("java/lang/Double"); + + ASSERT(Short.get<short>("MAX_VALUE") == short(0x7FFF)); + ASSERT(Character.get<wchar_t>("MAX_VALUE") == L'\xFFFF') + ASSERT(Integer.get<int>("MAX_VALUE") == int(0x7FFFFFFF)); + ASSERT(Long.get<long long>("MAX_VALUE") == (long long) (0x7FFFFFFFFFFFFFFF)); + ASSERT(std::isnan(Float.get<float>("NaN"))); + ASSERT(std::isnan(Double.get<double>("NaN"))); +} + +TEST(Class_getConstructor) +{ + jni::Class Integer("java/lang/Integer"); + jni::method_t constructor = Integer.getConstructor("(Ljava/lang/String;)V"); + + ASSERT(constructor); +} + +TEST(Class_call_staticMethod) +{ + jni::Class Integer("java/lang/Integer"); + jni::method_t method = Integer.getStaticMethod("parseInt", "(Ljava/lang/String;)I"); + + int i = Integer.call<int>(method, "1000"); + + ASSERT(i == 1000); +} + +TEST(Class_call_staticMethod_byName) +{ + int i = jni::Class("java/lang/Integer").call<int>("parseInt", "1000"); + bool b = jni::Class("java/lang/Boolean").call<bool>("parseBoolean", "true"); + wchar_t c = jni::Class("java/lang/Character").call<wchar_t>("toLowerCase", L'X'); + short s = jni::Class("java/lang/Short").call<short>("parseShort", "1000"); + long long l = jni::Class("java/lang/Long").call<long long>("parseLong", "1000"); + float f = jni::Class("java/lang/Float").call<float>("parseFloat", "123.0"); + double d = jni::Class("java/lang/Double").call<double>("parseDouble", "123.0"); + + ASSERT(i == 1000); + ASSERT(b == true); + ASSERT(c == L'x'); + ASSERT(s == 1000); + ASSERT(l == 1000); + ASSERT(f == 123.0); // Warning: floating point comparison. + ASSERT(d == 123.0); // Warning: floating point comparison. +} + +/* + jni::Object Tests + */ + +// Must run before loading JVM +TEST(Object_noDestructorException) +{ + jni::Object o; +} + +TEST(Object_defaultConstructor_isNull) +{ + jni::Object o; + + ASSERT(o.isNull()); +} + +TEST(Object_copyConstructorIsSameObject) +{ + jni::Object a = jni::Class("java/lang/String").newInstance(); + jni::Object b = a; + + ASSERT(a == b); +} + +TEST(Object_moveConstructor) +{ + jni::Object a = jni::Class("java/lang/String").newInstance(); + jni::Object b = std::move(a); + + ASSERT(a.isNull()); + ASSERT(!b.isNull()); +} + +TEST(Object_copyAssignmentOperator) +{ + jni::Object a = jni::Class("java/lang/String").newInstance(); + jni::Object b = jni::Class("java/lang/Integer").newInstance(0); + + a = b; + + ASSERT(a == b); +} + +TEST(Object_moveAssignmentOperator) +{ + jni::Object a = jni::Class("java/lang/String").newInstance(); + jni::Object b = jni::Class("java/lang/Integer").newInstance(0); + + a = std::move(b); + + ASSERT(!a.isNull()); + ASSERT(b.isNull()); +} + +TEST(Object_nullary_construct_from_signature) +{ + jni::Class String("java/lang/String"); + jni::method_t init = String.getMethod("<init>", "()V"); + jni::Object i = String.newInstance(init); + ASSERT(!i.isNull()); + jni::internal::ArgArray<> a; +} + +TEST(Object_call) +{ + jni::Class Integer("java/lang/Integer"); + jni::method_t intValue = Integer.getMethod("intValue", "()I"); + jni::Object i = Integer.newInstance(100); + + ASSERT(i.call<int>(intValue) == 100); +} + +TEST(Object_call_byName) +{ + jni::Object i = jni::Class("java/lang/Integer").newInstance(100); + jni::Object b = jni::Class("java/lang/Boolean").newInstance(true); + jni::Object s = jni::Class("java/lang/Short").newInstance(short(100)); + jni::Object l = jni::Class("java/lang/Long").newInstance(100LL); + jni::Object f = jni::Class("java/lang/Float").newInstance(100.0f); + jni::Object d = jni::Class("java/lang/Double").newInstance(100.0); + + ASSERT(i.call<int>("intValue") == 100); + ASSERT(s.call<short>("shortValue") == 100); + ASSERT(b.call<bool>("booleanValue") == true); + ASSERT(l.call<long long>("longValue") == 100LL); + ASSERT(f.call<float>("floatValue") == 100.0f); // Warning: Floating point comparison. + ASSERT(d.call<double>("doubleValue") == 100.0); // Warning: Floating point comparison. + ASSERT(i.call<std::wstring>("toString") == L"100"); + ASSERT(i.call<std::string>("toString") == "100"); +} + +TEST(Object_call_withArgs) +{ + jni::Class String("java/lang/String"); + jni::method_t charAt = String.getMethod("charAt", "(I)C"); + jni::Object str = String.newInstance("Testing"); + + ASSERT(str.call<wchar_t>(charAt, 1) == L'e'); +} + +TEST(Object_call_byNameWithArgs) +{ + jni::Object str = jni::Class("java/lang/String").newInstance("Testing"); + jni::Object str2 = jni::Class("java/lang/String").newInstance(L"Testing"); + + ASSERT(str.call<wchar_t>("charAt", 1) == L'e'); + ASSERT(str2.call<wchar_t>("charAt", 1) == L'e'); +} + +TEST(Object_call_returningArray) { + jni::Object str = jni::Class("java/lang/String").newInstance("Testing"); + + { + auto getBytes = + jni::Class("java/lang/String").getMethod("getBytes", "()[B"); + auto bytes = str.call<jni::Array<jni::byte_t>>(getBytes); + ASSERT(bytes.getLength() == 7); + } + { + auto bytes = str.call<jni::Array<jni::byte_t>>("getBytes"); + ASSERT(bytes.getLength() == 7); + } +} + +TEST(Object_makeLocalReference) +{ + jni::Object str = jni::Class("java/lang/String").newInstance("Testing"); + + jni::jobject local = str.makeLocalReference(); + ASSERT(local != nullptr); + ASSERT(local != str.getHandle()); + + jni::Object fromLocal(local, jni::Object::DeleteLocalInput); + ASSERT(!fromLocal.isNull()); + ASSERT(str == fromLocal); +} + +/* + jni::Enum Tests + */ + + +TEST(Enum_get) +{ + jni::Class Thread("java/lang/Thread"); + jni::Enum State("java/lang/Thread$State"); + jni::method_t currentThread = Thread.getStaticMethod("currentThread", "()Ljava/lang/Thread;"); + jni::method_t getState = Thread.getMethod("getState", "()Ljava/lang/Thread$State;"); + + jni::Object thread = Thread.call<jni::Object>(currentThread); + jni::Object state = thread.call<jni::Object>(getState); + + ASSERT(state == State.get("RUNNABLE")); +} + +/* + jni::Array Tests + */ + +TEST(Array_defaultConstructor) +{ + jni::Array<int> a; + + ASSERT(a.getLength() == 0); + ASSERT(a.isNull()); +} + +TEST(Array_constructor) +{ + jni::Array<int> a(10); + + ASSERT(a.getLength() == 10); + ASSERT(!a.isNull()); +} + +TEST(Array_constructor_eachType) +{ + jni::Array<bool> b(10); + jni::Array<wchar_t> c(10); + jni::Array<short> s(10); + jni::Array<int> i(10); + jni::Array<long long> l(10); + jni::Array<float> f(10); + jni::Array<double> d(10); + jni::Array<std::string> str(10); + jni::Array<std::wstring> wstr(10); + jni::Array<jni::Object> obj(10); + jni::Array<jni::Object> obj2(10, jni::Class("java/lang/Integer")); + + jni::Object* objs[] = { &b, &c, &s, &i, &l, &f, &d, &str, &wstr, &obj, &obj2 }; + + for (auto o : objs) + ASSERT(!o->isNull()); +} + +TEST(Array_constructor_withType) +{ + jni::Array<jni::Object> a(10, jni::Class("java/lang/Integer")); + + ASSERT(a.getLength() == 10); + ASSERT(!a.isNull()); +} + +TEST(Array_copyConstructor) +{ + jni::Array<int> a(10); + jni::Array<int> b = a; + + ASSERT(a == b); +} + +TEST(Array_moveConstructor) +{ + jni::Array<int> a(10); + jni::Array<int> b = std::move(a); + + ASSERT(a.isNull()); + ASSERT(!b.isNull()); +} + +TEST(Array_copyAssignmentOperator) +{ + jni::Array<int> a(10); + jni::Array<int> b(11); + + a = b; + + ASSERT(a == b); +} + +TEST(Array_moveAssignmentOperator) +{ + jni::Array<int> a(10); + jni::Array<int> b(11); + + a = std::move(b); + + ASSERT(!a.isNull()); + ASSERT(b.isNull()); +} + +TEST(Array_getElement_defaultValue) +{ + jni::Array<int> a(10); + jni::Array<std::string> s(10); + + ASSERT(a.getElement(0) == 0); + ASSERT(s.getElement(0).length() == 0); +} + +TEST(Array_getElement_indexException) +{ + jni::Array<int> a(10); + + try + { + int result = a.getElement(1000); + ASSERT(0); + } + catch (jni::Exception&) + { + ASSERT(1); + } +} + +TEST(Array_setElement_basicType) +{ + jni::Array<int> a(10); + + for (int i = 0; i < 10; i++) + a.setElement(i, i); + + for (int i = 0; i < 10; i++) + ASSERT(a.getElement(i) == i); +} + +TEST(Array_setElement_string) +{ + jni::Array<std::wstring> a(10); + + for (int i = 0; i < 10; i++) + a.setElement(i, std::to_wstring(i)); + + for (int i = 0; i < 10; i++) + ASSERT(a.getElement(i) == std::to_wstring(i)); +} + +TEST(Array_setElement_indexException) +{ + jni::Array<std::string> s(10); + + try + { + auto result = s.getElement(1000); + ASSERT(0); + } + catch (jni::Exception&) + { + ASSERT(1); + } +} + +/* + Argument Type Tests + */ + + +TEST(Arg_bool) +{ + std::string str1 = jni::Class("java/lang/String").call<std::string>("valueOf", true); + std::wstring str2 = jni::Class("java/lang/String").call<std::wstring>("valueOf", true); + + ASSERT(str1 == "true"); + ASSERT(str2 == L"true"); +} + +TEST(Arg_wchar) +{ + std::string str1 = jni::Class("java/lang/String").call<std::string>("valueOf", L'X'); + std::wstring str2 = jni::Class("java/lang/String").call<std::wstring>("valueOf", L'X'); + + ASSERT(str1 == "X"); + ASSERT(str2 == L"X"); +} + +TEST(Arg_double) +{ + std::string str1 = jni::Class("java/lang/String").call<std::string>("valueOf", 123.0); + std::wstring str2 = jni::Class("java/lang/String").call<std::wstring>("valueOf", 123.0); + + ASSERT(str1 == "123.0"); + ASSERT(str2 == L"123.0"); +} + +TEST(Arg_float) +{ + std::string str1 = jni::Class("java/lang/String").call<std::string>("valueOf", 123.0f); + std::wstring str2 = jni::Class("java/lang/String").call<std::wstring>("valueOf", 123.0f); + + ASSERT(str1 == "123.0"); + ASSERT(str2 == L"123.0"); +} + +TEST(Arg_int) +{ + std::string str1 = jni::Class("java/lang/String").call<std::string>("valueOf", 123); + std::wstring str2 = jni::Class("java/lang/String").call<std::wstring>("valueOf", 123); + + ASSERT(str1 == "123"); + ASSERT(str2 == L"123"); +} + +TEST(Arg_longLong) +{ + std::string str1 = jni::Class("java/lang/String").call<std::string>("valueOf", 123LL); + std::wstring str2 = jni::Class("java/lang/String").call<std::wstring>("valueOf", 123LL); + + ASSERT(str1 == "123"); + ASSERT(str2 == L"123"); +} + +TEST(Arg_Object) +{ + jni::Object str1 = jni::Class("java/lang/String").newInstance("123"); + int i = jni::Class("java/lang/Integer").call<int>("parseInt", str1); + + ASSERT(i == 123); +} + +TEST(Arg_ObjectPtr) +{ + jni::Object str1 = jni::Class("java/lang/String").newInstance("123"); + int i = jni::Class("java/lang/Integer").call<int>("parseInt", &str1); + + ASSERT(i == 123); +} + +int main() +{ + // Tests that depend on having no JVM + RUN_TEST(Object_noDestructorException); + + // jni::Vm Tests + RUN_TEST(Vm_detectsJreInstall); + RUN_TEST(Vm_notAllowedMultipleVms); + + { + jni::Vm vm; + + // jni::Class Tests + RUN_TEST(Class_findByName_success); + RUN_TEST(Class_findByName_failure); + RUN_TEST(Class_getName); + RUN_TEST(Class_getParent); + RUN_TEST(Class_newInstance); + RUN_TEST(Class_newInstance_withArgs); + RUN_TEST(Class_getStaticField); + RUN_TEST(Class_getMethod); + RUN_TEST(Class_getStaticMethod); + RUN_TEST(Class_call); + RUN_TEST(Class_get_staticField); + RUN_TEST(Class_get_staticField_byName); + RUN_TEST(Class_call_staticMethod_byName); + RUN_TEST(Class_getConstructor); + + // jni::Object Tests + RUN_TEST(Object_defaultConstructor_isNull); + RUN_TEST(Object_nullary_construct_from_signature); + RUN_TEST(Object_copyConstructorIsSameObject); + RUN_TEST(Object_moveConstructor); + RUN_TEST(Object_copyAssignmentOperator); + RUN_TEST(Object_moveAssignmentOperator); + RUN_TEST(Object_call); + RUN_TEST(Object_call_byName); + RUN_TEST(Object_call_withArgs); + RUN_TEST(Object_call_byNameWithArgs); + RUN_TEST(Object_call_returningArray); + RUN_TEST(Object_makeLocalReference); + + // jni::Enum Tests + RUN_TEST(Enum_get); + + // jni::Array Tests + RUN_TEST(Array_defaultConstructor); + RUN_TEST(Array_constructor); + RUN_TEST(Array_constructor_eachType); + RUN_TEST(Array_constructor_withType); + RUN_TEST(Array_copyConstructor); + RUN_TEST(Array_moveConstructor); + RUN_TEST(Array_getElement_defaultValue); + RUN_TEST(Array_getElement_indexException); + RUN_TEST(Array_setElement_basicType); + RUN_TEST(Array_setElement_string); + RUN_TEST(Array_setElement_indexException); + + // Argument Type Tests + RUN_TEST(Arg_bool); + RUN_TEST(Arg_wchar); + RUN_TEST(Arg_double); + RUN_TEST(Arg_float); + RUN_TEST(Arg_int); + RUN_TEST(Arg_longLong); + RUN_TEST(Arg_Object); + RUN_TEST(Arg_ObjectPtr); + } + + return 0; +} + diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/tests/testing.h b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/tests/testing.h new file mode 100644 index 0000000..4d6f6cc --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jnipp/tests/testing.h @@ -0,0 +1,33 @@ +#ifndef _TESTING_H_ +#define _TESTING_H_ 1 + +// Standard Dependencies +#include <iostream> +#include <iomanip> + +#ifdef ASSERT +# undef ASSERT +#endif + +/** Run the test with the given name. */ +#define RUN_TEST(TestName) { \ + bool __test_result = true; \ + std::cout << "Executing test " << std::left << std::setw(40) << #TestName; \ + TestName(__test_result); \ + std::cout << "=> " << (__test_result ? "Success" : "Fail") << std::endl; \ +} + +/** Define a test with the given name. */ +#define TEST(TestName) \ + void TestName(bool& __test_result) + +/** Ensures the given condition passes for the test to pass. */ +#define ASSERT(condition) { \ + if (!(condition)) { \ + __test_result = false; \ + return; \ + } \ +} + +#endif // _TESTING_H_ + diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/.clang-format b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/.clang-format new file mode 100644 index 0000000..b7cf997 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/.clang-format @@ -0,0 +1,4 @@ +BasedOnStyle: LLVM +DerivePointerAlignment: false +PointerAlignment: Left +SpacesBeforeTrailingComments: 1 diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/.clang-tidy b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/.clang-tidy new file mode 100644 index 0000000..99e914d --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/.clang-tidy @@ -0,0 +1,11 @@ +--- +Checks: 'google-readability-casting,modernize-deprecated-headers,modernize-loop-convert,modernize-use-auto,modernize-use-default-member-init,modernize-use-using,readability-else-after-return,readability-redundant-member-init,readability-redundant-string-cstr' +WarningsAsErrors: '' +HeaderFilterRegex: '' +AnalyzeTemporaryDtors: false +FormatStyle: none +CheckOptions: + - key: modernize-use-using.IgnoreMacros + value: '0' +... + diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/.gitattributes b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/.gitattributes new file mode 100644 index 0000000..22d2b7a --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/.gitattributes @@ -0,0 +1,11 @@ +* text=auto +*.h text +*.cpp text +*.json text +*.in text +*.sh eol=lf +*.bat eol=crlf +*.vcproj eol=crlf +*.vcxproj eol=crlf +*.sln eol=crlf +devtools/agent_vm* eol=crlf diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/.gitignore b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/.gitignore new file mode 100644 index 0000000..9682782 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/.gitignore @@ -0,0 +1,57 @@ +/build/ +/build-*/ +*.pyc +*.swp +*.actual +*.actual-rewrite +*.process-output +*.rewrite +/bin/ +/libs/ +/doc/doxyfile +/dist/ +/.cache/ + +# MSVC project files: +*.sln +*.vcxproj +*.filters +*.user +*.sdf +*.opensdf +*.suo + +# MSVC build files: +*.lib +*.obj +*.tlog/ +*.pdb + +# CMake-generated files: +CMakeFiles/ +/pkg-config/jsoncpp.pc +jsoncpp_lib_static.dir/ +compile_commands.json + +# In case someone runs cmake in the root-dir: +/CMakeCache.txt +/Makefile +/include/Makefile +/src/Makefile +/src/jsontestrunner/Makefile +/src/jsontestrunner/jsontestrunner_exe +/src/lib_json/Makefile +/src/test_lib_json/Makefile +/src/test_lib_json/jsoncpp_test +*.a + +# eclipse project files +.project +.cproject +/.settings/ + +# DS_Store +.DS_Store + +# temps +/version diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/AUTHORS b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/AUTHORS new file mode 100644 index 0000000..e1fa0fc --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/AUTHORS @@ -0,0 +1,115 @@ +Baptiste Lepilleur <blep@users.sourceforge.net> + +Aaron Jacobs <aaronjjacobs@gmail.com> +Aaron Jacobs <jacobsa@google.com> +Adam Boseley <ABoseley@agjunction.com> +Adam Boseley <adam.boseley@gmail.com> +Aleksandr Derbenev <13alexac@gmail.com> +Alexander Gazarov <DrMetallius@users.noreply.github.com> +Alexander V. Brezgin <abrezgin@appliedtech.ru> +Alexandr Brezgin <albrezgin@mail.ru> +Alexey Kruchinin <alexey@mopals.com> +Anton Indrawan <anton.indrawan@gmail.com> +Baptiste Jonglez <git@bitsofnetworks.org> +Baptiste Lepilleur <baptiste.lepilleur@gmail.com> +Baruch Siach <baruch@tkos.co.il> +Ben Boeckel <mathstuf@gmail.com> +Benjamin Knecht <bknecht@logitech.com> +Bernd Kuhls <bernd.kuhls@t-online.de> +Billy Donahue <billydonahue@google.com> +Braden McDorman <bmcdorman@gmail.com> +Brandon Myers <bmyers1788@gmail.com> +Brendan Drew <brendan.drew@daqri.com> +chason <cxchao802@gmail.com> +chenguoping <chenguopingdota@163.com> +Chris Gilling <cgilling@iparadigms.com> +Christopher Dawes <christopher.dawes.1981@googlemail.com> +Christopher Dunn <cdunn2001@gmail.com> +Chuck Atkins <chuck.atkins@kitware.com> +Cody P Schafer <dev@codyps.com> +Connor Manning <connor@hobu.co> +Cory Quammen <cory.quammen@kitware.com> +Cristóvão B da Cruz e Silva <CrisXed@gmail.com> +Daniel Krügler <daniel.kruegler@gmail.com> +Dani-Hub <daniel.kruegler@googlemail.com> +Dan Liu <gzliudan> +datadiode <datadiode@users.noreply.github.com> +datadiode <jochen.neubeck@vodafone.de> +David Seifert <soap@gentoo.org> +David West <david-west@idexx.com> +dawesc <chris.dawes@eftlab.co.uk> +Devin Jeanpierre <jeanpierreda@google.com> +Dmitry Marakasov <amdmi3@amdmi3.ru> +dominicpezzuto <dom@dompezzuto.com> +Don Milham <dmilham@gmail.com> +drgler <daniel.kruegler@gmail.com> +ds283 <D.Seery@sussex.ac.uk> +Egor Tensin <Egor.Tensin@gmail.com> +eightnoteight <mr.eightnoteight@gmail.com> +Evince <baneyue@gmail.com> +filipjs <filipjs@users.noreply.github.com> +findblar <ft@finbarr.ca> +Florian Meier <florian.meier@koalo.de> +Gaëtan Lehmann <gaetan.lehmann@gmail.com> +Gaurav <g.gupta@samsung.com> +Gergely Nagy <ngg@ngg.hu> +Gida Pataki <gida.pataki@prezi.com> +I3ck <buckmartin@buckmartin.de> +Iñaki Baz Castillo <ibc@aliax.net> +Jacco <jacco@geul.net> +Jean-Christophe Fillion-Robin <jchris.fillionr@kitware.com> +Jonas Platte <mail@jonasplatte.de> +Jordan Bayles <bayles.jordan@gmail.com> +Jörg Krause <joerg.krause@embedded.rocks> +Keith Lea <keith@whamcitylights.com> +Kevin Grant <kbradleygrant@gmail.com> +Kirill V. Lyadvinsky <jia3ep@gmail.com> +Kirill V. Lyadvinsky <mail@codeatcpp.com> +Kobi Gurkan <kobigurk@gmail.com> +Magnus Bjerke Vik <mbvett@gmail.com> +Malay Shah <malays@users.sourceforge.net> +Mara Kim <hacker.root@gmail.com> +Marek Kotewicz <marek.kotewicz@gmail.com> +Mark Lakata <mark@lakata.org> +Mark Zeren <mzeren@vmware.com> +Martin Buck <buckmartin@buckmartin.de> +Martyn Gigg <martyn.gigg@gmail.com> +Mattes D <github@xoft.cz> +Matthias Loy <matthias.loy@hbm.com> +Merlyn Morgan-Graham <kavika@gmail.com> +Michael Shields <mshields@google.com> +Michał Górny <mgorny@gentoo.org> +Mike Naberezny <mike@naberezny.com> +mloy <matthias.loy@googlemail.com> +Motti <lanzkron@gmail.com> +nnkur <nnkur@mail.ru> +Omkar Wagh <owagh@owaghlinux.ny.tower-research.com> +paulo <paulobrizolara@users.noreply.github.com> +pavel.pimenov <pavel.pimenov@gmail.com> +Paweł Bylica <chfast@gmail.com> +Péricles Lopes Machado <pericles.raskolnikoff@gmail.com> +Peter Spiess-Knafl <psk@autistici.org> +pffang <pffang@vip.qq.com> +Rémi Verschelde <remi@verschelde.fr> +renu555 <renu.tyagi@samsung.com> +Robert Dailey <rcdailey@gmail.com> +Sam Clegg <sbc@chromium.org> +selaselah <selah@outlook.com> +Sergiy80 <sil2004@gmail.com> +sergzub <sergzub@gmail.com> +Stefan Schweter <stefan@schweter.it> +Stefano Fiorentino <stefano.fiore84@gmail.com> +Steffen Kieß <Steffen.Kiess@ipvs.uni-stuttgart.de> +Steven Hahn <hahnse@ornl.gov> +Stuart Eichert <stuart@fivemicro.com> +SuperManitu <supermanitu@gmail.com> +Techwolf <dring@g33kworld.net> +Tengiz Sharafiev <btolfa+github@gmail.com> +Tomasz Maciejewski <tmaciejewsk@gmail.com> +Vicente Olivert Riera <Vincent.Riera@imgtec.com> +xiaoyur347 <xiaoyur347@gmail.com> +ycqiu <429148848@qq.com> +yiqiju <fred_ju@selinc.com> +Yu Xiaolei <dreifachstein@gmail.com> + +Google Inc. diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/BUILD.bazel b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/BUILD.bazel new file mode 100644 index 0000000..6d7ac3d --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/BUILD.bazel @@ -0,0 +1,37 @@ +licenses(["unencumbered"]) # Public Domain or MIT + +exports_files(["LICENSE"]) + +cc_library( + name = "jsoncpp", + srcs = [ + "src/lib_json/json_reader.cpp", + "src/lib_json/json_tool.h", + "src/lib_json/json_value.cpp", + "src/lib_json/json_writer.cpp", + ], + hdrs = [ + "include/json/allocator.h", + "include/json/assertions.h", + "include/json/config.h", + "include/json/json_features.h", + "include/json/forwards.h", + "include/json/json.h", + "include/json/reader.h", + "include/json/value.h", + "include/json/version.h", + "include/json/writer.h", + ], + copts = [ + "-DJSON_USE_EXCEPTION=0", + "-DJSON_HAS_INT64", + ], + includes = ["include"], + visibility = ["//visibility:public"], + deps = [":private"], +) + +cc_library( + name = "private", + textual_hdrs = ["src/lib_json/json_valueiterator.inl"], +) diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/CMakeLists.txt b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/CMakeLists.txt new file mode 100644 index 0000000..f11425c --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/CMakeLists.txt @@ -0,0 +1,207 @@ +# vim: et ts=4 sts=4 sw=4 tw=0 + +# ==== Define cmake build policies that affect compilation and linkage default behaviors +# +# Set the JSONCPP_NEWEST_VALIDATED_POLICIES_VERSION string to the newest cmake version +# policies that provide successful builds. By setting JSONCPP_NEWEST_VALIDATED_POLICIES_VERSION +# to a value greater than the oldest policies, all policies between +# JSONCPP_OLDEST_VALIDATED_POLICIES_VERSION and CMAKE_VERSION (used for this build) +# are set to their NEW behavior, thereby suppressing policy warnings related to policies +# between the JSONCPP_OLDEST_VALIDATED_POLICIES_VERSION and CMAKE_VERSION. +# +# CMake versions greater than the JSONCPP_NEWEST_VALIDATED_POLICIES_VERSION policies will +# continue to generate policy warnings "CMake Warning (dev)...Policy CMP0XXX is not set:" +# +set(JSONCPP_OLDEST_VALIDATED_POLICIES_VERSION "3.8.0") +set(JSONCPP_NEWEST_VALIDATED_POLICIES_VERSION "3.13.2") +cmake_minimum_required(VERSION ${JSONCPP_OLDEST_VALIDATED_POLICIES_VERSION}) +if("${CMAKE_VERSION}" VERSION_LESS "${JSONCPP_NEWEST_VALIDATED_POLICIES_VERSION}") + #Set and use the newest available cmake policies that are validated to work + set(JSONCPP_CMAKE_POLICY_VERSION "${CMAKE_VERSION}") +else() + set(JSONCPP_CMAKE_POLICY_VERSION "${JSONCPP_NEWEST_VALIDATED_POLICIES_VERSION}") +endif() +cmake_policy(VERSION ${JSONCPP_CMAKE_POLICY_VERSION}) +if(POLICY CMP0091) + cmake_policy(SET CMP0091 NEW) +endif() +# +# Now enumerate specific policies newer than JSONCPP_NEWEST_VALIDATED_POLICIES_VERSION +# that may need to be individually set to NEW/OLD +# +foreach(pnew "") # Currently Empty + if(POLICY ${pnew}) + cmake_policy(SET ${pnew} NEW) + endif() +endforeach() +foreach(pold "") # Currently Empty + if(POLICY ${pold}) + cmake_policy(SET ${pold} OLD) + endif() +endforeach() + +# Build the library with C++11 standard support, independent from other including +# software which may use a different CXX_STANDARD or CMAKE_CXX_STANDARD. +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_EXTENSIONS OFF) +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +# Ensure that CMAKE_BUILD_TYPE has a value specified for single configuration generators. +if(NOT DEFINED CMAKE_BUILD_TYPE AND NOT DEFINED CMAKE_CONFIGURATION_TYPES) + set(CMAKE_BUILD_TYPE Release CACHE STRING + "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel Coverage.") +endif() + +set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake") + +project(jsoncpp + # Note: version must be updated in three places when doing a release. This + # annoying process ensures that amalgamate, CMake, and meson all report the + # correct version. + # 1. ./meson.build + # 2. ./include/json/version.h + # 3. ./CMakeLists.txt + # IMPORTANT: also update the PROJECT_SOVERSION!! + VERSION 1.9.6 # <major>[.<minor>[.<patch>[.<tweak>]]] + LANGUAGES CXX) + +message(STATUS "JsonCpp Version: ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}") +set(PROJECT_SOVERSION 26) + +include(${CMAKE_CURRENT_SOURCE_DIR}/include/PreventInSourceBuilds.cmake) +include(${CMAKE_CURRENT_SOURCE_DIR}/include/PreventInBuildInstalls.cmake) + +option(JSONCPP_WITH_TESTS "Compile and (for jsoncpp_check) run JsonCpp test executables" ON) +option(JSONCPP_WITH_POST_BUILD_UNITTEST "Automatically run unit-tests as a post build step" ON) +option(JSONCPP_WITH_WARNING_AS_ERROR "Force compilation to fail if a warning occurs" OFF) +option(JSONCPP_WITH_STRICT_ISO "Issue all the warnings demanded by strict ISO C and ISO C++" ON) +option(JSONCPP_WITH_PKGCONFIG_SUPPORT "Generate and install .pc files" ON) +option(JSONCPP_WITH_CMAKE_PACKAGE "Generate and install cmake package files" ON) +option(JSONCPP_WITH_EXAMPLE "Compile JsonCpp example" OFF) +option(JSONCPP_STATIC_WINDOWS_RUNTIME "Use static (MT/MTd) Windows runtime" OFF) +option(BUILD_SHARED_LIBS "Build jsoncpp_lib as a shared library." ON) +option(BUILD_STATIC_LIBS "Build jsoncpp_lib as a static library." ON) +option(BUILD_OBJECT_LIBS "Build jsoncpp_lib as a object library." ON) + +# Adhere to GNU filesystem layout conventions +include(GNUInstallDirs) + +if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR) + set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib" CACHE PATH "Archive output dir.") + set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib" CACHE PATH "Library output dir.") + set(CMAKE_PDB_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin" CACHE PATH "PDB (MSVC debug symbol)output dir.") + set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin" CACHE PATH "Executable/dll output dir.") +endif() + +if(JSONCPP_USE_SECURE_MEMORY) + add_definitions("-DJSONCPP_USE_SECURE_MEMORY=1") +endif() + +configure_file("${PROJECT_SOURCE_DIR}/version.in" + "${PROJECT_BINARY_DIR}/version" + NEWLINE_STYLE UNIX) + +macro(use_compilation_warning_as_error) + if(MSVC) + # Only enabled in debug because some old versions of VS STL generate + # warnings when compiled in release configuration. + add_compile_options($<$<CONFIG:Debug>:/WX>) + elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") + add_compile_options(-Werror) + if(JSONCPP_WITH_STRICT_ISO) + add_compile_options(-pedantic-errors) + endif() + endif() +endmacro() + +# Include our configuration header +include_directories(${jsoncpp_SOURCE_DIR}/include) + +if(MSVC) + # Only enabled in debug because some old versions of VS STL generate + # unreachable code warning when compiled in release configuration. + add_compile_options($<$<CONFIG:Debug>:/W4>) + if (JSONCPP_STATIC_WINDOWS_RUNTIME) + set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>") + endif() +endif() + +if(CMAKE_CXX_COMPILER_ID MATCHES "Clang") + # using regular Clang or AppleClang + add_compile_options(-Wall -Wconversion -Wshadow) + + if(JSONCPP_WITH_WARNING_AS_ERROR) + add_compile_options(-Werror=conversion -Werror=sign-compare) + endif() +elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") + # using GCC + add_compile_options(-Wall -Wconversion -Wshadow -Wextra) + # not yet ready for -Wsign-conversion + + if(JSONCPP_WITH_STRICT_ISO) + add_compile_options(-Wpedantic) + endif() + if(JSONCPP_WITH_WARNING_AS_ERROR) + add_compile_options(-Werror=conversion) + endif() +elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel") + # using Intel compiler + add_compile_options(-Wall -Wconversion -Wshadow -Wextra) + + if(JSONCPP_WITH_WARNING_AS_ERROR) + add_compile_options(-Werror=conversion) + elseif(JSONCPP_WITH_STRICT_ISO) + add_compile_options(-Wpedantic) + endif() +endif() + +if(JSONCPP_WITH_WARNING_AS_ERROR) + use_compilation_warning_as_error() +endif() + +if(JSONCPP_WITH_PKGCONFIG_SUPPORT) + include(JoinPaths) + + join_paths(libdir_for_pc_file "\${exec_prefix}" "${CMAKE_INSTALL_LIBDIR}") + join_paths(includedir_for_pc_file "\${prefix}" "${CMAKE_INSTALL_INCLUDEDIR}") + + configure_file( + "pkg-config/jsoncpp.pc.in" + "pkg-config/jsoncpp.pc" + @ONLY) + install(FILES "${CMAKE_CURRENT_BINARY_DIR}/pkg-config/jsoncpp.pc" + DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig") +endif() + +if(JSONCPP_WITH_CMAKE_PACKAGE) + include(CMakePackageConfigHelpers) + install(EXPORT jsoncpp + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/jsoncpp + FILE jsoncpp-targets.cmake) + configure_package_config_file(jsoncppConfig.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/jsoncppConfig.cmake + INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/jsoncpp) + + write_basic_package_version_file("${CMAKE_CURRENT_BINARY_DIR}/jsoncppConfigVersion.cmake" + VERSION ${PROJECT_VERSION} + COMPATIBILITY SameMajorVersion) + install(FILES + ${CMAKE_CURRENT_BINARY_DIR}/jsoncppConfigVersion.cmake ${CMAKE_CURRENT_BINARY_DIR}/jsoncppConfig.cmake + ${CMAKE_CURRENT_SOURCE_DIR}/jsoncpp-namespaced-targets.cmake + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/jsoncpp) +endif() + +if(JSONCPP_WITH_TESTS) + enable_testing() + include(CTest) +endif() + +# Build the different applications +add_subdirectory(src) + +#install the includes +add_subdirectory(include) + +#install the example +if(JSONCPP_WITH_EXAMPLE) + add_subdirectory(example) +endif() diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/CONTRIBUTING.md b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/CONTRIBUTING.md new file mode 100644 index 0000000..5f5c032 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/CONTRIBUTING.md @@ -0,0 +1,152 @@ +# Contributing to JsonCpp + +## Building + +Both CMake and Meson tools are capable of generating a variety of build environments for you preferred development environment. +Using cmake or meson you can generate an XCode, Visual Studio, Unix Makefile, Ninja, or other environment that fits your needs. + +An example of a common Meson/Ninja environment is described next. + +## Building and testing with Meson/Ninja +Thanks to David Seifert (@SoapGentoo), we (the maintainers) now use +[meson](http://mesonbuild.com/) and [ninja](https://ninja-build.org/) to build +for debugging, as well as for continuous integration (see +[`./.travis_scripts/meson_builder.sh`](./.travis_scripts/meson_builder.sh) ). Other systems may work, but minor +things like version strings might break. + +First, install both meson (which requires Python3) and ninja. +If you wish to install to a directory other than /usr/local, set an environment variable called DESTDIR with the desired path: + DESTDIR=/path/to/install/dir + +Then, +```sh + cd jsoncpp/ + BUILD_TYPE=debug + #BUILD_TYPE=release + LIB_TYPE=shared + #LIB_TYPE=static + meson --buildtype ${BUILD_TYPE} --default-library ${LIB_TYPE} . build-${LIB_TYPE} + ninja -v -C build-${LIB_TYPE} + + ninja -C build-static/ test + + # Or + #cd build-${LIB_TYPE} + #meson test --no-rebuild --print-errorlogs + + sudo ninja install +``` + +## Building and testing with other build systems +See https://github.com/open-source-parsers/jsoncpp/wiki/Building + +## Running the tests manually + +You need to run tests manually only if you are troubleshooting an issue. + +In the instructions below, replace `path/to/jsontest` with the path of the +`jsontest` executable that was compiled on your platform. + + cd test + # This will run the Reader/Writer tests + python runjsontests.py path/to/jsontest + + # This will run the Reader/Writer tests, using JSONChecker test suite + # (http://www.json.org/JSON_checker/). + # Notes: not all tests pass: JsonCpp is too lenient (for example, + # it allows an integer to start with '0'). The goal is to improve + # strict mode parsing to get all tests to pass. + python runjsontests.py --with-json-checker path/to/jsontest + + # This will run the unit tests (mostly Value) + python rununittests.py path/to/test_lib_json + + # You can run the tests using valgrind: + python rununittests.py --valgrind path/to/test_lib_json + +## Building the documentation + +Run the Python script `doxybuild.py` from the top directory: + + python doxybuild.py --doxygen=$(which doxygen) --open --with-dot + +See `doxybuild.py --help` for options. + +## Adding a reader/writer test + +To add a test, you need to create two files in test/data: + +* a `TESTNAME.json` file, that contains the input document in JSON format. +* a `TESTNAME.expected` file, that contains a flattened representation of the + input document. + +The `TESTNAME.expected` file format is as follows: + +* Each line represents a JSON element of the element tree represented by the + input document. +* Each line has two parts: the path to access the element separated from the + element value by `=`. Array and object values are always empty (i.e. + represented by either `[]` or `{}`). +* Element path `.` represents the root element, and is used to separate object + members. `[N]` is used to specify the value of an array element at index `N`. + +See the examples `test_complex_01.json` and `test_complex_01.expected` to better understand element paths. + +## Understanding reader/writer test output + +When a test is run, output files are generated beside the input test files. Below is a short description of the content of each file: + +* `test_complex_01.json`: input JSON document. +* `test_complex_01.expected`: flattened JSON element tree used to check if + parsing was corrected. +* `test_complex_01.actual`: flattened JSON element tree produced by `jsontest` + from reading `test_complex_01.json`. +* `test_complex_01.rewrite`: JSON document written by `jsontest` using the + `Json::Value` parsed from `test_complex_01.json` and serialized using + `Json::StyledWritter`. +* `test_complex_01.actual-rewrite`: flattened JSON element tree produced by + `jsontest` from reading `test_complex_01.rewrite`. +* `test_complex_01.process-output`: `jsontest` output, typically useful for + understanding parsing errors. + +## Versioning rules + +Consumers of this library require a strict approach to incrementing versioning of the JsonCpp library. Currently, we follow the below set of rules: + +* Any new public symbols require a minor version bump. +* Any alteration or removal of public symbols requires a major version bump, including changing the size of a class. This is necessary for +consumers to do dependency injection properly. + +## Preparing code for submission + +Generally, JsonCpp's style guide has been pretty relaxed, with the following common themes: + +* Variables and function names use lower camel case (E.g. parseValue or collectComments). +* Class use camel case (e.g. OurReader) +* Member variables have a trailing underscore +* Prefer `nullptr` over `NULL`. +* Passing by non-const reference is allowed. +* Single statement if blocks may omit brackets. +* Generally prefer less space over more space. + +For an example: + +```c++ +bool Reader::decodeNumber(Token& token) { + Value decoded; + if (!decodeNumber(token, decoded)) + return false; + currentValue().swapPayload(decoded); + currentValue().setOffsetStart(token.start_ - begin_); + currentValue().setOffsetLimit(token.end_ - begin_); + return true; +} +``` + +Before submitting your code, ensure that you meet the versioning requirements above, follow the style guide of the file you are modifying (or the above rules for new files), and run clang format. Meson exposes clang format with the following command: +``` +ninja -v -C build-${LIB_TYPE}/ clang-format +``` + +For convenience, you can also run the `reformat.sh` script located in the root directory. + diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/CTestConfig.cmake b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/CTestConfig.cmake new file mode 100644 index 0000000..b8fc6d5 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/CTestConfig.cmake @@ -0,0 +1,15 @@ +## This file should be placed in the root directory of your project. +## Then modify the CMakeLists.txt file in the root directory of your +## project to incorporate the testing dashboard. +## +## # The following are required to submit to the CDash dashboard: +## ENABLE_TESTING() +## INCLUDE(CTest) + +set(CTEST_PROJECT_NAME "jsoncpp") +set(CTEST_NIGHTLY_START_TIME "01:23:45 UTC") + +set(CTEST_DROP_METHOD "https") +set(CTEST_DROP_SITE "my.cdash.org") +set(CTEST_DROP_LOCATION "/submit.php?project=jsoncpp") +set(CTEST_DROP_SITE_CDASH TRUE) diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/LICENSE b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/LICENSE new file mode 100644 index 0000000..c41a1d1 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/LICENSE @@ -0,0 +1,55 @@ +The JsonCpp library's source code, including accompanying documentation, +tests and demonstration applications, are licensed under the following +conditions... + +Baptiste Lepilleur and The JsonCpp Authors explicitly disclaim copyright in all +jurisdictions which recognize such a disclaimer. In such jurisdictions, +this software is released into the Public Domain. + +In jurisdictions which do not recognize Public Domain property (e.g. Germany as of +2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur and +The JsonCpp Authors, and is released under the terms of the MIT License (see below). + +In jurisdictions which recognize Public Domain property, the user of this +software may choose to accept it either as 1) Public Domain, 2) under the +conditions of the MIT License (see below), or 3) under the terms of dual +Public Domain/MIT License conditions described here, as they choose. + +The MIT License is about as close to Public Domain as a license can get, and is +described in clear, concise terms at: + + http://en.wikipedia.org/wiki/MIT_License + +The full text of the MIT License follows: + +======================================================================== +Copyright (c) 2007-2010 Baptiste Lepilleur and The JsonCpp Authors + +Permission is hereby granted, free of charge, to any person +obtaining a copy of this software and associated documentation +files (the "Software"), to deal in the Software without +restriction, including without limitation the rights to use, copy, +modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS +BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +======================================================================== +(END LICENSE TEXT) + +The MIT license is compatible with both the GPL and commercial +software, affording one all of the rights of Public Domain with the +minor nuisance of being required to keep the above copyright notice +and license text in the source code. Note also that by accepting the +Public Domain "license" you can re-license your copy using whatever +license you like. diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/README.md b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/README.md new file mode 100644 index 0000000..5bff8dc --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/README.md @@ -0,0 +1,67 @@ +# JsonCpp + +[![badge](https://img.shields.io/badge/conan.io-jsoncpp%2F1.8.0-green.svg?logo=data:image/png;base64%2CiVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAMAAAAolt3jAAAA1VBMVEUAAABhlctjlstkl8tlmMtlmMxlmcxmmcxnmsxpnMxpnM1qnc1sn85voM91oM11oc1xotB2oc56pNF6pNJ2ptJ8ptJ8ptN9ptN8p9N5qNJ9p9N9p9R8qtOBqdSAqtOAqtR%2BrNSCrNJ/rdWDrNWCsNWCsNaJs9eLs9iRvNuVvdyVv9yXwd2Zwt6axN6dxt%2Bfx%2BChyeGiyuGjyuCjyuGly%2BGlzOKmzOGozuKoz%2BKqz%2BOq0OOv1OWw1OWw1eWx1eWy1uay1%2Baz1%2Baz1%2Bez2Oe02Oe12ee22ujUGwH3AAAAAXRSTlMAQObYZgAAAAFiS0dEAIgFHUgAAAAJcEhZcwAACxMAAAsTAQCanBgAAAAHdElNRQfgBQkREyOxFIh/AAAAiklEQVQI12NgAAMbOwY4sLZ2NtQ1coVKWNvoc/Eq8XDr2wB5Ig62ekza9vaOqpK2TpoMzOxaFtwqZua2Bm4makIM7OzMAjoaCqYuxooSUqJALjs7o4yVpbowvzSUy87KqSwmxQfnsrPISyFzWeWAXCkpMaBVIC4bmCsOdgiUKwh3JojLgAQ4ZCE0AMm2D29tZwe6AAAAAElFTkSuQmCC)](https://bintray.com/theirix/conan-repo/jsoncpp%3Atheirix) +[![badge](https://img.shields.io/badge/license-MIT-blue)](https://github.com/open-source-parsers/jsoncpp/blob/master/LICENSE) +[![badge](https://img.shields.io/badge/document-doxygen-brightgreen)](http://open-source-parsers.github.io/jsoncpp-docs/doxygen/index.html) +[![Coverage Status](https://coveralls.io/repos/github/open-source-parsers/jsoncpp/badge.svg?branch=master)](https://coveralls.io/github/open-source-parsers/jsoncpp?branch=master) + + +[JSON][json-org] is a lightweight data-interchange format. It can represent +numbers, strings, ordered sequences of values, and collections of name/value +pairs. + +[json-org]: http://json.org/ + +JsonCpp is a C++ library that allows manipulating JSON values, including +serialization and deserialization to and from strings. It can also preserve +existing comment in unserialization/serialization steps, making it a convenient +format to store user input files. + + +## Documentation + +[JsonCpp documentation][JsonCpp-documentation] is generated using [Doxygen][]. + +[JsonCpp-documentation]: http://open-source-parsers.github.io/jsoncpp-docs/doxygen/index.html +[Doxygen]: http://www.doxygen.org + + +## A note on backward-compatibility + +* `1.y.z` is built with C++11. +* `0.y.z` can be used with older compilers. +* `00.11.z` can be used both in old and new compilers. +* Major versions maintain binary-compatibility. + +### Special note +The branch `00.11.z`is a new branch, its major version number `00` is to show that it is +different from `0.y.z` and `1.y.z`, the main purpose of this branch is to make a balance +between the other two branches. Thus, users can use some new features in this new branch +that introduced in 1.y.z, but can hardly applied into 0.y.z. + +## Using JsonCpp in your project + +### The vcpkg dependency manager +You can download and install JsonCpp using the [vcpkg](https://github.com/Microsoft/vcpkg/) dependency manager: + + git clone https://github.com/Microsoft/vcpkg.git + cd vcpkg + ./bootstrap-vcpkg.sh + ./vcpkg integrate install + ./vcpkg install jsoncpp + +The JsonCpp port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository. + +### Amalgamated source +https://github.com/open-source-parsers/jsoncpp/wiki/Amalgamated-(Possibly-outdated) + +### The Meson Build System +If you are using the [Meson Build System](http://mesonbuild.com), then you can get a wrap file by downloading it from [Meson WrapDB](https://wrapdb.mesonbuild.com/jsoncpp), or simply use `meson wrap install jsoncpp`. + +### Other ways +If you have trouble, see the [Wiki](https://github.com/open-source-parsers/jsoncpp/wiki), or post a question as an Issue. + +## License + +See the `LICENSE` file for details. In summary, JsonCpp is licensed under the +MIT license, or public domain if desired and recognized in your jurisdiction. diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/SECURITY.md b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/SECURITY.md new file mode 100644 index 0000000..67af883 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/SECURITY.md @@ -0,0 +1,17 @@ +# Security Policy + +If you have discovered a security vulnerability in this project, please report it +privately. **Do not disclose it as a public issue.** This gives us time to work with you +to fix the issue before public exposure, reducing the chance that the exploit will be +used before a patch is released. + +Please submit the report by filling out +[this form](https://github.com/open-source-parsers/jsoncpp/security/advisories/new). + +Please provide the following information in your report: + +- A description of the vulnerability and its impact +- How to reproduce the issue + +This project is maintained by volunteers on a reasonable-effort basis. As such, +we ask that you give us 90 days to work on a fix before public exposure. diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/amalgamate.py b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/amalgamate.py new file mode 100644 index 0000000..1d1e488 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/amalgamate.py @@ -0,0 +1,161 @@ +#!/usr/bin/env python + +"""Amalgamate json-cpp library sources into a single source and header file. + +Works with python2.6+ and python3.4+. + +Example of invocation (must be invoked from json-cpp top directory): +python amalgamate.py +""" +import os +import os.path +import sys + +INCLUDE_PATH = "include/json" +SRC_PATH = "src/lib_json" + +class AmalgamationFile: + def __init__(self, top_dir): + self.top_dir = top_dir + self.blocks = [] + + def add_text(self, text): + if not text.endswith("\n"): + text += "\n" + self.blocks.append(text) + + def add_file(self, relative_input_path, wrap_in_comment=False): + def add_marker(prefix): + self.add_text("") + self.add_text("// " + "/"*70) + self.add_text("// %s of content of file: %s" % (prefix, relative_input_path.replace("\\","/"))) + self.add_text("// " + "/"*70) + self.add_text("") + add_marker("Beginning") + f = open(os.path.join(self.top_dir, relative_input_path), "rt") + content = f.read() + if wrap_in_comment: + content = "/*\n" + content + "\n*/" + self.add_text(content) + f.close() + add_marker("End") + self.add_text("\n\n\n\n") + + def get_value(self): + return "".join(self.blocks).replace("\r\n","\n") + + def write_to(self, output_path): + output_dir = os.path.dirname(output_path) + if output_dir and not os.path.isdir(output_dir): + os.makedirs(output_dir) + f = open(output_path, "wb") + f.write(str.encode(self.get_value(), 'UTF-8')) + f.close() + +def amalgamate_source(source_top_dir=None, + target_source_path=None, + header_include_path=None): + """Produces amalgamated source. + Parameters: + source_top_dir: top-directory + target_source_path: output .cpp path + header_include_path: generated header path relative to target_source_path. + """ + print("Amalgamating header...") + header = AmalgamationFile(source_top_dir) + header.add_text("/// Json-cpp amalgamated header (https://github.com/open-source-parsers/jsoncpp/).") + header.add_text('/// It is intended to be used with #include "%s"' % header_include_path) + header.add_file("LICENSE", wrap_in_comment=True) + header.add_text("#ifndef JSON_AMALGAMATED_H_INCLUDED") + header.add_text("# define JSON_AMALGAMATED_H_INCLUDED") + header.add_text("/// If defined, indicates that the source file is amalgamated") + header.add_text("/// to prevent private header inclusion.") + header.add_text("#define JSON_IS_AMALGAMATION") + header.add_file(os.path.join(INCLUDE_PATH, "version.h")) + header.add_file(os.path.join(INCLUDE_PATH, "allocator.h")) + header.add_file(os.path.join(INCLUDE_PATH, "config.h")) + header.add_file(os.path.join(INCLUDE_PATH, "forwards.h")) + header.add_file(os.path.join(INCLUDE_PATH, "json_features.h")) + header.add_file(os.path.join(INCLUDE_PATH, "value.h")) + header.add_file(os.path.join(INCLUDE_PATH, "reader.h")) + header.add_file(os.path.join(INCLUDE_PATH, "writer.h")) + header.add_file(os.path.join(INCLUDE_PATH, "assertions.h")) + header.add_text("#endif //ifndef JSON_AMALGAMATED_H_INCLUDED") + + target_header_path = os.path.join(os.path.dirname(target_source_path), header_include_path) + print("Writing amalgamated header to %r" % target_header_path) + header.write_to(target_header_path) + + base, ext = os.path.splitext(header_include_path) + forward_header_include_path = base + "-forwards" + ext + print("Amalgamating forward header...") + header = AmalgamationFile(source_top_dir) + header.add_text("/// Json-cpp amalgamated forward header (https://github.com/open-source-parsers/jsoncpp/).") + header.add_text('/// It is intended to be used with #include "%s"' % forward_header_include_path) + header.add_text("/// This header provides forward declaration for all JsonCpp types.") + header.add_file("LICENSE", wrap_in_comment=True) + header.add_text("#ifndef JSON_FORWARD_AMALGAMATED_H_INCLUDED") + header.add_text("# define JSON_FORWARD_AMALGAMATED_H_INCLUDED") + header.add_text("/// If defined, indicates that the source file is amalgamated") + header.add_text("/// to prevent private header inclusion.") + header.add_text("#define JSON_IS_AMALGAMATION") + header.add_file(os.path.join(INCLUDE_PATH, "version.h")) + header.add_file(os.path.join(INCLUDE_PATH, "allocator.h")) + header.add_file(os.path.join(INCLUDE_PATH, "config.h")) + header.add_file(os.path.join(INCLUDE_PATH, "forwards.h")) + header.add_text("#endif //ifndef JSON_FORWARD_AMALGAMATED_H_INCLUDED") + + target_forward_header_path = os.path.join(os.path.dirname(target_source_path), + forward_header_include_path) + print("Writing amalgamated forward header to %r" % target_forward_header_path) + header.write_to(target_forward_header_path) + + print("Amalgamating source...") + source = AmalgamationFile(source_top_dir) + source.add_text("/// Json-cpp amalgamated source (https://github.com/open-source-parsers/jsoncpp/).") + source.add_text('/// It is intended to be used with #include "%s"' % header_include_path) + source.add_file("LICENSE", wrap_in_comment=True) + source.add_text("") + source.add_text('#include "%s"' % header_include_path) + source.add_text(""" +#ifndef JSON_IS_AMALGAMATION +#error "Compile with -I PATH_TO_JSON_DIRECTORY" +#endif +""") + source.add_text("") + source.add_file(os.path.join(SRC_PATH, "json_tool.h")) + source.add_file(os.path.join(SRC_PATH, "json_reader.cpp")) + source.add_file(os.path.join(SRC_PATH, "json_valueiterator.inl")) + source.add_file(os.path.join(SRC_PATH, "json_value.cpp")) + source.add_file(os.path.join(SRC_PATH, "json_writer.cpp")) + + print("Writing amalgamated source to %r" % target_source_path) + source.write_to(target_source_path) + +def main(): + usage = """%prog [options] +Generate a single amalgamated source and header file from the sources. +""" + from optparse import OptionParser + parser = OptionParser(usage=usage) + parser.allow_interspersed_args = False + parser.add_option("-s", "--source", dest="target_source_path", action="store", default="dist/jsoncpp.cpp", + help="""Output .cpp source path. [Default: %default]""") + parser.add_option("-i", "--include", dest="header_include_path", action="store", default="json/json.h", + help="""Header include path. Used to include the header from the amalgamated source file. [Default: %default]""") + parser.add_option("-t", "--top-dir", dest="top_dir", action="store", default=os.getcwd(), + help="""Source top-directory. [Default: %default]""") + parser.enable_interspersed_args() + options, args = parser.parse_args() + + msg = amalgamate_source(source_top_dir=options.top_dir, + target_source_path=options.target_source_path, + header_include_path=options.header_include_path) + if msg: + sys.stderr.write(msg + "\n") + sys.exit(1) + else: + print("Source successfully amalgamated") + +if __name__ == "__main__": + main() diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/appveyor.yml b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/appveyor.yml new file mode 100644 index 0000000..cccce42 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/appveyor.yml @@ -0,0 +1,37 @@ +clone_folder: c:\projects\jsoncpp + +environment: + + matrix: + - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015 + CMAKE_GENERATOR: Visual Studio 14 2015 + - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015 + CMAKE_GENERATOR: Visual Studio 14 2015 Win64 + - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 + CMAKE_GENERATOR: Visual Studio 15 2017 + - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 + CMAKE_GENERATOR: Visual Studio 15 2017 Win64 + +build_script: + - cmake --version + # The build script starts in root. + - set JSONCPP_FOLDER=%cd% + - set JSONCPP_BUILD_FOLDER=%JSONCPP_FOLDER%\build\release + - mkdir -p %JSONCPP_BUILD_FOLDER% + - cd %JSONCPP_BUILD_FOLDER% + - cmake -G "%CMAKE_GENERATOR%" -DCMAKE_INSTALL_PREFIX:PATH=%CD:\=/%/install -DBUILD_SHARED_LIBS:BOOL=ON %JSONCPP_FOLDER% + # Use ctest to make a dashboard build: + # - ctest -D Experimental(Start|Update|Configure|Build|Test|Coverage|MemCheck|Submit) + # NOTE: Testing on windows is not yet finished: + # - ctest -C Release -D ExperimentalStart -D ExperimentalConfigure -D ExperimentalBuild -D ExperimentalTest -D ExperimentalSubmit + - ctest -C Release -D ExperimentalStart -D ExperimentalConfigure -D ExperimentalBuild -D ExperimentalSubmit + # Final step is to verify that installation succeeds + - cmake --build . --config Release --target install + +deploy: + provider: GitHub + auth_token: + secure: K2Tp1q8pIZ7rs0Ot24ZMWuwr12Ev6Tc6QkhMjGQxoQG3ng1pXtgPasiJ45IDXGdg + on: + branch: master + appveyor_repo_tag: true diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/cmake/JoinPaths.cmake b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/cmake/JoinPaths.cmake new file mode 100644 index 0000000..2b376b7 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/cmake/JoinPaths.cmake @@ -0,0 +1,23 @@ +# This module provides a function for joining paths +# known from most languages +# +# SPDX-License-Identifier: (MIT OR CC0-1.0) +# Copyright 2020 Jan Tojnar +# https://github.com/jtojnar/cmake-snips +# +# Modelled after Python’s os.path.join +# https://docs.python.org/3.7/library/os.path.html#os.path.join +# Windows not supported +function(join_paths joined_path first_path_segment) + set(temp_path "${first_path_segment}") + foreach(current_segment IN LISTS ARGN) + if(NOT ("${current_segment}" STREQUAL "")) + if(IS_ABSOLUTE "${current_segment}") + set(temp_path "${current_segment}") + else() + set(temp_path "${temp_path}/${current_segment}") + endif() + endif() + endforeach() + set(${joined_path} "${temp_path}" PARENT_SCOPE) +endfunction() diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/dev.makefile b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/dev.makefile new file mode 100644 index 0000000..545ff27 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/dev.makefile @@ -0,0 +1,37 @@ +# This is only for jsoncpp developers/contributors. +# We use this to sign releases, generate documentation, etc. +VER?=$(shell cat version) + +default: + @echo "VER=${VER}" +update-version: + perl get_version.pl meson.build >| version +sign: jsoncpp-${VER}.tar.gz + gpg --armor --detach-sign $< + gpg --verify $<.asc + # Then upload .asc to the release. +jsoncpp-%.tar.gz: + curl https://github.com/open-source-parsers/jsoncpp/archive/$*.tar.gz -o $@ +dox: + python doxybuild.py --doxygen=$$(which doxygen) --in doc/web_doxyfile.in + rsync -va -c --delete dist/doxygen/jsoncpp-api-html-${VER}/ ../jsoncpp-docs/doxygen/ + # Then 'git add -A' and 'git push' in jsoncpp-docs. +build: + mkdir -p build/debug + cd build/debug; cmake -DCMAKE_BUILD_TYPE=debug -DBUILD_SHARED_LIBS=ON -G "Unix Makefiles" ../.. + make -C build/debug + +# Currently, this depends on include/json/version.h generated +# by cmake. +test-amalgamate: + python2.7 amalgamate.py + python3.4 amalgamate.py + cd dist; gcc -I. -c jsoncpp.cpp + +valgrind: + valgrind --error-exitcode=42 --leak-check=full ./build/debug/src/test_lib_json/jsoncpp_test + +clean: + \rm -rf *.gz *.asc dist/ + +.PHONY: build diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/__init__.py b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/__init__.py new file mode 100644 index 0000000..4a51e65 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/__init__.py @@ -0,0 +1,6 @@ +# Copyright 2010 Baptiste Lepilleur and The JsonCpp Authors +# Distributed under MIT license, or public domain if desired and +# recognized in your jurisdiction. +# See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE + +# module diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/agent_vmw7.json b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/agent_vmw7.json new file mode 100644 index 0000000..cd7b777 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/agent_vmw7.json @@ -0,0 +1,33 @@ +{ + "cmake_variants" : [ + {"name": "generator", + "generators": [ + {"generator": [ + "Visual Studio 7 .NET 2003", + "Visual Studio 9 2008", + "Visual Studio 9 2008 Win64", + "Visual Studio 10", + "Visual Studio 10 Win64", + "Visual Studio 11", + "Visual Studio 11 Win64" + ] + }, + {"generator": ["MinGW Makefiles"], + "env_prepend": [{"path": "c:/wut/prg/MinGW/bin"}] + } + ] + }, + {"name": "shared_dll", + "variables": [ + ["BUILD_SHARED_LIBS=true"], + ["BUILD_SHARED_LIBS=false"] + ] + }, + {"name": "build_type", + "build_types": [ + "debug", + "release" + ] + } + ] +} diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/agent_vmxp.json b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/agent_vmxp.json new file mode 100644 index 0000000..f82a077 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/agent_vmxp.json @@ -0,0 +1,26 @@ +{ + "cmake_variants" : [ + {"name": "generator", + "generators": [ + {"generator": [ + "Visual Studio 6", + "Visual Studio 7", + "Visual Studio 8 2005" + ] + } + ] + }, + {"name": "shared_dll", + "variables": [ + ["BUILD_SHARED_LIBS=true"], + ["BUILD_SHARED_LIBS=false"] + ] + }, + {"name": "build_type", + "build_types": [ + "debug", + "release" + ] + } + ] +} diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/antglob.py b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/antglob.py new file mode 100644 index 0000000..bd2d7ae --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/antglob.py @@ -0,0 +1,205 @@ +#!/usr/bin/env python +# encoding: utf-8 +# Copyright 2009 Baptiste Lepilleur and The JsonCpp Authors +# Distributed under MIT license, or public domain if desired and +# recognized in your jurisdiction. +# See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE + +from __future__ import print_function +from dircache import listdir +import re +import fnmatch +import os.path + + +# These fnmatch expressions are used by default to prune the directory tree +# while doing the recursive traversal in the glob_impl method of glob function. +prune_dirs = '.git .bzr .hg .svn _MTN _darcs CVS SCCS ' + +# These fnmatch expressions are used by default to exclude files and dirs +# while doing the recursive traversal in the glob_impl method of glob function. +##exclude_pats = prune_pats + '*~ #*# .#* %*% ._* .gitignore .cvsignore vssver.scc .DS_Store'.split() + +# These ant_glob expressions are used by default to exclude files and dirs and also prune the directory tree +# while doing the recursive traversal in the glob_impl method of glob function. +default_excludes = ''' +**/*~ +**/#*# +**/.#* +**/%*% +**/._* +**/CVS +**/CVS/** +**/.cvsignore +**/SCCS +**/SCCS/** +**/vssver.scc +**/.svn +**/.svn/** +**/.git +**/.git/** +**/.gitignore +**/.bzr +**/.bzr/** +**/.hg +**/.hg/** +**/_MTN +**/_MTN/** +**/_darcs +**/_darcs/** +**/.DS_Store ''' + +DIR = 1 +FILE = 2 +DIR_LINK = 4 +FILE_LINK = 8 +LINKS = DIR_LINK | FILE_LINK +ALL_NO_LINK = DIR | FILE +ALL = DIR | FILE | LINKS + +_ANT_RE = re.compile(r'(/\*\*/)|(\*\*/)|(/\*\*)|(\*)|(/)|([^\*/]*)') + +def ant_pattern_to_re(ant_pattern): + """Generates a regular expression from the ant pattern. + Matching convention: + **/a: match 'a', 'dir/a', 'dir1/dir2/a' + a/**/b: match 'a/b', 'a/c/b', 'a/d/c/b' + *.py: match 'script.py' but not 'a/script.py' + """ + rex = ['^'] + next_pos = 0 + sep_rex = r'(?:/|%s)' % re.escape(os.path.sep) +## print 'Converting', ant_pattern + for match in _ANT_RE.finditer(ant_pattern): +## print 'Matched', match.group() +## print match.start(0), next_pos + if match.start(0) != next_pos: + raise ValueError("Invalid ant pattern") + if match.group(1): # /**/ + rex.append(sep_rex + '(?:.*%s)?' % sep_rex) + elif match.group(2): # **/ + rex.append('(?:.*%s)?' % sep_rex) + elif match.group(3): # /** + rex.append(sep_rex + '.*') + elif match.group(4): # * + rex.append('[^/%s]*' % re.escape(os.path.sep)) + elif match.group(5): # / + rex.append(sep_rex) + else: # somepath + rex.append(re.escape(match.group(6))) + next_pos = match.end() + rex.append('$') + return re.compile(''.join(rex)) + +def _as_list(l): + if isinstance(l, basestring): + return l.split() + return l + +def glob(dir_path, + includes = '**/*', + excludes = default_excludes, + entry_type = FILE, + prune_dirs = prune_dirs, + max_depth = 25): + include_filter = [ant_pattern_to_re(p) for p in _as_list(includes)] + exclude_filter = [ant_pattern_to_re(p) for p in _as_list(excludes)] + prune_dirs = [p.replace('/',os.path.sep) for p in _as_list(prune_dirs)] + dir_path = dir_path.replace('/',os.path.sep) + entry_type_filter = entry_type + + def is_pruned_dir(dir_name): + for pattern in prune_dirs: + if fnmatch.fnmatch(dir_name, pattern): + return True + return False + + def apply_filter(full_path, filter_rexs): + """Return True if at least one of the filter regular expression match full_path.""" + for rex in filter_rexs: + if rex.match(full_path): + return True + return False + + def glob_impl(root_dir_path): + child_dirs = [root_dir_path] + while child_dirs: + dir_path = child_dirs.pop() + for entry in listdir(dir_path): + full_path = os.path.join(dir_path, entry) +## print 'Testing:', full_path, + is_dir = os.path.isdir(full_path) + if is_dir and not is_pruned_dir(entry): # explore child directory ? +## print '===> marked for recursion', + child_dirs.append(full_path) + included = apply_filter(full_path, include_filter) + rejected = apply_filter(full_path, exclude_filter) + if not included or rejected: # do not include entry ? +## print '=> not included or rejected' + continue + link = os.path.islink(full_path) + is_file = os.path.isfile(full_path) + if not is_file and not is_dir: +## print '=> unknown entry type' + continue + if link: + entry_type = is_file and FILE_LINK or DIR_LINK + else: + entry_type = is_file and FILE or DIR +## print '=> type: %d' % entry_type, + if (entry_type & entry_type_filter) != 0: +## print ' => KEEP' + yield os.path.join(dir_path, entry) +## else: +## print ' => TYPE REJECTED' + return list(glob_impl(dir_path)) + + +if __name__ == "__main__": + import unittest + + class AntPatternToRETest(unittest.TestCase): +## def test_conversion(self): +## self.assertEqual('^somepath$', ant_pattern_to_re('somepath').pattern) + + def test_matching(self): + test_cases = [ ('path', + ['path'], + ['somepath', 'pathsuffix', '/path', '/path']), + ('*.py', + ['source.py', 'source.ext.py', '.py'], + ['path/source.py', '/.py', 'dir.py/z', 'z.pyc', 'z.c']), + ('**/path', + ['path', '/path', '/a/path', 'c:/a/path', '/a/b/path', '//a/path', '/a/path/b/path'], + ['path/', 'a/path/b', 'dir.py/z', 'somepath', 'pathsuffix', 'a/somepath']), + ('path/**', + ['path/a', 'path/path/a', 'path//'], + ['path', 'somepath/a', 'a/path', 'a/path/a', 'pathsuffix/a']), + ('/**/path', + ['/path', '/a/path', '/a/b/path/path', '/path/path'], + ['path', 'path/', 'a/path', '/pathsuffix', '/somepath']), + ('a/b', + ['a/b'], + ['somea/b', 'a/bsuffix', 'a/b/c']), + ('**/*.py', + ['script.py', 'src/script.py', 'a/b/script.py', '/a/b/script.py'], + ['script.pyc', 'script.pyo', 'a.py/b']), + ('src/**/*.py', + ['src/a.py', 'src/dir/a.py'], + ['a/src/a.py', '/src/a.py']), + ] + for ant_pattern, accepted_matches, rejected_matches in list(test_cases): + def local_path(paths): + return [ p.replace('/',os.path.sep) for p in paths ] + test_cases.append((ant_pattern, local_path(accepted_matches), local_path(rejected_matches))) + for ant_pattern, accepted_matches, rejected_matches in test_cases: + rex = ant_pattern_to_re(ant_pattern) + print('ant_pattern:', ant_pattern, ' => ', rex.pattern) + for accepted_match in accepted_matches: + print('Accepted?:', accepted_match) + self.assertTrue(rex.match(accepted_match) is not None) + for rejected_match in rejected_matches: + print('Rejected?:', rejected_match) + self.assertTrue(rex.match(rejected_match) is None) + + unittest.main() diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/batchbuild.py b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/batchbuild.py new file mode 100644 index 0000000..0eb0690 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/batchbuild.py @@ -0,0 +1,278 @@ +from __future__ import print_function +import collections +import itertools +import json +import os +import os.path +import re +import shutil +import string +import subprocess +import sys +import cgi + +class BuildDesc: + def __init__(self, prepend_envs=None, variables=None, build_type=None, generator=None): + self.prepend_envs = prepend_envs or [] # [ { "var": "value" } ] + self.variables = variables or [] + self.build_type = build_type + self.generator = generator + + def merged_with(self, build_desc): + """Returns a new BuildDesc by merging field content. + Prefer build_desc fields to self fields for single valued field. + """ + return BuildDesc(self.prepend_envs + build_desc.prepend_envs, + self.variables + build_desc.variables, + build_desc.build_type or self.build_type, + build_desc.generator or self.generator) + + def env(self): + environ = os.environ.copy() + for values_by_name in self.prepend_envs: + for var, value in list(values_by_name.items()): + var = var.upper() + if type(value) is unicode: + value = value.encode(sys.getdefaultencoding()) + if var in environ: + environ[var] = value + os.pathsep + environ[var] + else: + environ[var] = value + return environ + + def cmake_args(self): + args = ["-D%s" % var for var in self.variables] + # skip build type for Visual Studio solution as it cause warning + if self.build_type and 'Visual' not in self.generator: + args.append("-DCMAKE_BUILD_TYPE=%s" % self.build_type) + if self.generator: + args.extend(['-G', self.generator]) + return args + + def __repr__(self): + return "BuildDesc(%s, build_type=%s)" % (" ".join(self.cmake_args()), self.build_type) + +class BuildData: + def __init__(self, desc, work_dir, source_dir): + self.desc = desc + self.work_dir = work_dir + self.source_dir = source_dir + self.cmake_log_path = os.path.join(work_dir, 'batchbuild_cmake.log') + self.build_log_path = os.path.join(work_dir, 'batchbuild_build.log') + self.cmake_succeeded = False + self.build_succeeded = False + + def execute_build(self): + print('Build %s' % self.desc) + self._make_new_work_dir() + self.cmake_succeeded = self._generate_makefiles() + if self.cmake_succeeded: + self.build_succeeded = self._build_using_makefiles() + return self.build_succeeded + + def _generate_makefiles(self): + print(' Generating makefiles: ', end=' ') + cmd = ['cmake'] + self.desc.cmake_args() + [os.path.abspath(self.source_dir)] + succeeded = self._execute_build_subprocess(cmd, self.desc.env(), self.cmake_log_path) + print('done' if succeeded else 'FAILED') + return succeeded + + def _build_using_makefiles(self): + print(' Building:', end=' ') + cmd = ['cmake', '--build', self.work_dir] + if self.desc.build_type: + cmd += ['--config', self.desc.build_type] + succeeded = self._execute_build_subprocess(cmd, self.desc.env(), self.build_log_path) + print('done' if succeeded else 'FAILED') + return succeeded + + def _execute_build_subprocess(self, cmd, env, log_path): + process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=self.work_dir, + env=env) + stdout, _ = process.communicate() + succeeded = (process.returncode == 0) + with open(log_path, 'wb') as flog: + log = ' '.join(cmd) + '\n' + stdout + '\nExit code: %r\n' % process.returncode + flog.write(fix_eol(log)) + return succeeded + + def _make_new_work_dir(self): + if os.path.isdir(self.work_dir): + print(' Removing work directory', self.work_dir) + shutil.rmtree(self.work_dir, ignore_errors=True) + if not os.path.isdir(self.work_dir): + os.makedirs(self.work_dir) + +def fix_eol(stdout): + """Fixes wrong EOL produced by cmake --build on Windows (\r\r\n instead of \r\n). + """ + return re.sub('\r*\n', os.linesep, stdout) + +def load_build_variants_from_config(config_path): + with open(config_path, 'rb') as fconfig: + data = json.load(fconfig) + variants = data[ 'cmake_variants' ] + build_descs_by_axis = collections.defaultdict(list) + for axis in variants: + axis_name = axis["name"] + build_descs = [] + if "generators" in axis: + for generator_data in axis["generators"]: + for generator in generator_data["generator"]: + build_desc = BuildDesc(generator=generator, + prepend_envs=generator_data.get("env_prepend")) + build_descs.append(build_desc) + elif "variables" in axis: + for variables in axis["variables"]: + build_desc = BuildDesc(variables=variables) + build_descs.append(build_desc) + elif "build_types" in axis: + for build_type in axis["build_types"]: + build_desc = BuildDesc(build_type=build_type) + build_descs.append(build_desc) + build_descs_by_axis[axis_name].extend(build_descs) + return build_descs_by_axis + +def generate_build_variants(build_descs_by_axis): + """Returns a list of BuildDesc generated for the partial BuildDesc for each axis.""" + axis_names = list(build_descs_by_axis.keys()) + build_descs = [] + for axis_name, axis_build_descs in list(build_descs_by_axis.items()): + if len(build_descs): + # for each existing build_desc and each axis build desc, create a new build_desc + new_build_descs = [] + for prototype_build_desc, axis_build_desc in itertools.product(build_descs, axis_build_descs): + new_build_descs.append(prototype_build_desc.merged_with(axis_build_desc)) + build_descs = new_build_descs + else: + build_descs = axis_build_descs + return build_descs + +HTML_TEMPLATE = string.Template('''<html> +<head> + <title>$title + + + + + + + + $th_vars + + + + $th_build_types + + + +$tr_builds + +
Variables
Build type
+''') + +def generate_html_report(html_report_path, builds): + report_dir = os.path.dirname(html_report_path) + # Vertical axis: generator + # Horizontal: variables, then build_type + builds_by_generator = collections.defaultdict(list) + variables = set() + build_types_by_variable = collections.defaultdict(set) + build_by_pos_key = {} # { (generator, var_key, build_type): build } + for build in builds: + builds_by_generator[build.desc.generator].append(build) + var_key = tuple(sorted(build.desc.variables)) + variables.add(var_key) + build_types_by_variable[var_key].add(build.desc.build_type) + pos_key = (build.desc.generator, var_key, build.desc.build_type) + build_by_pos_key[pos_key] = build + variables = sorted(variables) + th_vars = [] + th_build_types = [] + for variable in variables: + build_types = sorted(build_types_by_variable[variable]) + nb_build_type = len(build_types_by_variable[variable]) + th_vars.append('%s' % (nb_build_type, cgi.escape(' '.join(variable)))) + for build_type in build_types: + th_build_types.append('%s' % cgi.escape(build_type)) + tr_builds = [] + for generator in sorted(builds_by_generator): + tds = [ '%s\n' % cgi.escape(generator) ] + for variable in variables: + build_types = sorted(build_types_by_variable[variable]) + for build_type in build_types: + pos_key = (generator, variable, build_type) + build = build_by_pos_key.get(pos_key) + if build: + cmake_status = 'ok' if build.cmake_succeeded else 'FAILED' + build_status = 'ok' if build.build_succeeded else 'FAILED' + cmake_log_url = os.path.relpath(build.cmake_log_path, report_dir) + build_log_url = os.path.relpath(build.build_log_path, report_dir) + td = 'CMake: %s' % ( build_status.lower(), cmake_log_url, cmake_status.lower(), cmake_status) + if build.cmake_succeeded: + td += '
Build: %s' % ( build_log_url, build_status.lower(), build_status) + td += '' + else: + td = '' + tds.append(td) + tr_builds.append('%s' % '\n'.join(tds)) + html = HTML_TEMPLATE.substitute( title='Batch build report', + th_vars=' '.join(th_vars), + th_build_types=' '.join(th_build_types), + tr_builds='\n'.join(tr_builds)) + with open(html_report_path, 'wt') as fhtml: + fhtml.write(html) + print('HTML report generated in:', html_report_path) + +def main(): + usage = r"""%prog WORK_DIR SOURCE_DIR CONFIG_JSON_PATH [CONFIG2_JSON_PATH...] +Build a given CMake based project located in SOURCE_DIR with multiple generators/options.dry_run +as described in CONFIG_JSON_PATH building in WORK_DIR. + +Example of call: +python devtools\batchbuild.py e:\buildbots\jsoncpp\build . devtools\agent_vmw7.json +""" + from optparse import OptionParser + parser = OptionParser(usage=usage) + parser.allow_interspersed_args = True +# parser.add_option('-v', '--verbose', dest="verbose", action='store_true', +# help="""Be verbose.""") + parser.enable_interspersed_args() + options, args = parser.parse_args() + if len(args) < 3: + parser.error("Missing one of WORK_DIR SOURCE_DIR CONFIG_JSON_PATH.") + work_dir = args[0] + source_dir = args[1].rstrip('/\\') + config_paths = args[2:] + for config_path in config_paths: + if not os.path.isfile(config_path): + parser.error("Can not read: %r" % config_path) + + # generate build variants + build_descs = [] + for config_path in config_paths: + build_descs_by_axis = load_build_variants_from_config(config_path) + build_descs.extend(generate_build_variants(build_descs_by_axis)) + print('Build variants (%d):' % len(build_descs)) + # assign build directory for each variant + if not os.path.isdir(work_dir): + os.makedirs(work_dir) + builds = [] + with open(os.path.join(work_dir, 'matrix-dir-map.txt'), 'wt') as fmatrixmap: + for index, build_desc in enumerate(build_descs): + build_desc_work_dir = os.path.join(work_dir, '%03d' % (index+1)) + builds.append(BuildData(build_desc, build_desc_work_dir, source_dir)) + fmatrixmap.write('%s: %s\n' % (build_desc_work_dir, build_desc)) + for build in builds: + build.execute_build() + html_report_path = os.path.join(work_dir, 'batchbuild-report.html') + generate_html_report(html_report_path, builds) + print('Done') + + +if __name__ == '__main__': + main() + diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/fixeol.py b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/fixeol.py new file mode 100644 index 0000000..11e1ce2 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/fixeol.py @@ -0,0 +1,70 @@ +# Copyright 2010 Baptiste Lepilleur and The JsonCpp Authors +# Distributed under MIT license, or public domain if desired and +# recognized in your jurisdiction. +# See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE + +from __future__ import print_function +import os.path +import sys + +def fix_source_eol(path, is_dry_run = True, verbose = True, eol = '\n'): + """Makes sure that all sources have the specified eol sequence (default: unix).""" + if not os.path.isfile(path): + raise ValueError('Path "%s" is not a file' % path) + try: + f = open(path, 'rb') + except IOError as msg: + print("%s: I/O Error: %s" % (file, str(msg)), file=sys.stderr) + return False + try: + raw_lines = f.readlines() + finally: + f.close() + fixed_lines = [line.rstrip('\r\n') + eol for line in raw_lines] + if raw_lines != fixed_lines: + print('%s =>' % path, end=' ') + if not is_dry_run: + f = open(path, "wb") + try: + f.writelines(fixed_lines) + finally: + f.close() + if verbose: + print(is_dry_run and ' NEED FIX' or ' FIXED') + return True +## +## +## +##def _do_fix(is_dry_run = True): +## from waftools import antglob +## python_sources = antglob.glob('.', +## includes = '**/*.py **/wscript **/wscript_build', +## excludes = antglob.default_excludes + './waf.py', +## prune_dirs = antglob.prune_dirs + 'waf-* ./build') +## for path in python_sources: +## _fix_python_source(path, is_dry_run) +## +## cpp_sources = antglob.glob('.', +## includes = '**/*.cpp **/*.h **/*.inl', +## prune_dirs = antglob.prune_dirs + 'waf-* ./build') +## for path in cpp_sources: +## _fix_source_eol(path, is_dry_run) +## +## +##def dry_fix(context): +## _do_fix(is_dry_run = True) +## +##def fix(context): +## _do_fix(is_dry_run = False) +## +##def shutdown(): +## pass +## +##def check(context): +## # Unit tests are run when "check" target is used +## ut = UnitTest.unit_test() +## ut.change_to_testfile_dir = True +## ut.want_to_see_test_output = True +## ut.want_to_see_test_error = True +## ut.run() +## ut.print_results() diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/licenseupdater.py b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/licenseupdater.py new file mode 100644 index 0000000..d9b662e --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/licenseupdater.py @@ -0,0 +1,94 @@ +"""Updates the license text in source file. +""" +from __future__ import print_function + +# An existing license is found if the file starts with the string below, +# and ends with the first blank line. +LICENSE_BEGIN = "// Copyright " + +BRIEF_LICENSE = LICENSE_BEGIN + """2007-2010 Baptiste Lepilleur and The JsonCpp Authors +// Distributed under MIT license, or public domain if desired and +// recognized in your jurisdiction. +// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE + +""".replace('\r\n','\n') + +def update_license(path, dry_run, show_diff): + """Update the license statement in the specified file. + Parameters: + path: path of the C++ source file to update. + dry_run: if True, just print the path of the file that would be updated, + but don't change it. + show_diff: if True, print the path of the file that would be modified, + as well as the change made to the file. + """ + with open(path, 'rt') as fin: + original_text = fin.read().replace('\r\n','\n') + newline = fin.newlines and fin.newlines[0] or '\n' + if not original_text.startswith(LICENSE_BEGIN): + # No existing license found => prepend it + new_text = BRIEF_LICENSE + original_text + else: + license_end_index = original_text.index('\n\n') # search first blank line + new_text = BRIEF_LICENSE + original_text[license_end_index+2:] + if original_text != new_text: + if not dry_run: + with open(path, 'wb') as fout: + fout.write(new_text.replace('\n', newline)) + print('Updated', path) + if show_diff: + import difflib + print('\n'.join(difflib.unified_diff(original_text.split('\n'), + new_text.split('\n')))) + return True + return False + +def update_license_in_source_directories(source_dirs, dry_run, show_diff): + """Updates license text in C++ source files found in directory source_dirs. + Parameters: + source_dirs: list of directory to scan for C++ sources. Directories are + scanned recursively. + dry_run: if True, just print the path of the file that would be updated, + but don't change it. + show_diff: if True, print the path of the file that would be modified, + as well as the change made to the file. + """ + from devtools import antglob + prune_dirs = antglob.prune_dirs + 'scons-local* ./build* ./libs ./dist' + for source_dir in source_dirs: + cpp_sources = antglob.glob(source_dir, + includes = '''**/*.h **/*.cpp **/*.inl''', + prune_dirs = prune_dirs) + for source in cpp_sources: + update_license(source, dry_run, show_diff) + +def main(): + usage = """%prog DIR [DIR2...] +Updates license text in sources of the project in source files found +in the directory specified on the command-line. + +Example of call: +python devtools\licenseupdater.py include src -n --diff +=> Show change that would be made to the sources. + +python devtools\licenseupdater.py include src +=> Update license statement on all sources in directories include/ and src/. +""" + from optparse import OptionParser + parser = OptionParser(usage=usage) + parser.allow_interspersed_args = False + parser.add_option('-n', '--dry-run', dest="dry_run", action='store_true', default=False, + help="""Only show what files are updated, do not update the files""") + parser.add_option('--diff', dest="show_diff", action='store_true', default=False, + help="""On update, show change made to the file.""") + parser.enable_interspersed_args() + options, args = parser.parse_args() + update_license_in_source_directories(args, options.dry_run, options.show_diff) + print('Done') + +if __name__ == '__main__': + import sys + import os.path + sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + main() + diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/tarball.py b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/tarball.py new file mode 100644 index 0000000..3c0ba65 --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/devtools/tarball.py @@ -0,0 +1,52 @@ +# Copyright 2010 Baptiste Lepilleur and The JsonCpp Authors +# Distributed under MIT license, or public domain if desired and +# recognized in your jurisdiction. +# See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE + +from contextlib import closing +import os +import tarfile + +TARGZ_DEFAULT_COMPRESSION_LEVEL = 9 + +def make_tarball(tarball_path, sources, base_dir, prefix_dir=''): + """Parameters: + tarball_path: output path of the .tar.gz file + sources: list of sources to include in the tarball, relative to the current directory + base_dir: if a source file is in a sub-directory of base_dir, then base_dir is stripped + from path in the tarball. + prefix_dir: all files stored in the tarball be sub-directory of prefix_dir. Set to '' + to make them child of root. + """ + base_dir = os.path.normpath(os.path.abspath(base_dir)) + def archive_name(path): + """Makes path relative to base_dir.""" + path = os.path.normpath(os.path.abspath(path)) + common_path = os.path.commonprefix((base_dir, path)) + archive_name = path[len(common_path):] + if os.path.isabs(archive_name): + archive_name = archive_name[1:] + return os.path.join(prefix_dir, archive_name) + def visit(tar, dirname, names): + for name in names: + path = os.path.join(dirname, name) + if os.path.isfile(path): + path_in_tar = archive_name(path) + tar.add(path, path_in_tar) + compression = TARGZ_DEFAULT_COMPRESSION_LEVEL + with closing(tarfile.TarFile.open(tarball_path, 'w:gz', + compresslevel=compression)) as tar: + for source in sources: + source_path = source + if os.path.isdir(source): + for dirpath, dirnames, filenames in os.walk(source_path): + visit(tar, dirpath, filenames) + else: + path_in_tar = archive_name(source_path) + tar.add(source_path, path_in_tar) # filename, arcname + +def decompress(tarball_path, base_dir): + """Decompress the gzipped tarball into directory base_dir. + """ + with closing(tarfile.TarFile.open(tarball_path)) as tar: + tar.extractall(base_dir) diff --git a/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/doc/doxyfile.in b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/doc/doxyfile.in new file mode 100644 index 0000000..dcf514e --- /dev/null +++ b/shadps4-arm64-main/externals/openxr-sdk/src/external/jsoncpp/doc/doxyfile.in @@ -0,0 +1,2302 @@ +# Doxyfile 1.8.5 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project. +# +# All text after a double hash (##) is considered a comment and is placed in +# front of the TAG it is preceding. +# +# All text after a single hash (#) is considered a comment and will be ignored. +# The format is: +# TAG = value [value, ...] +# For lists, items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (\" \"). + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- + +# This tag specifies the encoding used for all characters in the config file +# that follow. The default is UTF-8 which is also the encoding used for all text +# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv +# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv +# for the list of possible encodings. +# The default value is: UTF-8. + +DOXYFILE_ENCODING = UTF-8 + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by +# double-quotes, unless you are using Doxywizard) that should identify the +# project for which the documentation is generated. This name is used in the +# title of most generated pages and in a few other places. +# The default value is: My Project. + +PROJECT_NAME = "JsonCpp" + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. This +# could be handy for archiving the generated documentation or if some version +# control system is used. + +PROJECT_NUMBER = %JSONCPP_VERSION% + +# Using the PROJECT_BRIEF tag one can provide an optional one line description +# for a project that appears at the top of each page and should give viewer a +# quick idea about the purpose of the project. Keep the description short. + +PROJECT_BRIEF = + +# With the PROJECT_LOGO tag one can specify an logo or icon that is included in +# the documentation. The maximum height of the logo should not exceed 55 pixels +# and the maximum width should not exceed 200 pixels. Doxygen will copy the logo +# to the output directory. + +PROJECT_LOGO = + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path +# into which the generated documentation will be written. If a relative path is +# entered, it will be relative to the location where doxygen was started. If +# left blank the current directory will be used. + +OUTPUT_DIRECTORY = %DOC_TOPDIR% + +# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 4096 sub- +# directories (in 2 levels) under the output directory of each output format and +# will distribute the generated files over these directories. Enabling this +# option can be useful when feeding doxygen a huge amount of source files, where +# putting all generated files in the same directory would otherwise causes +# performance problems for the file system. +# The default value is: NO. + +CREATE_SUBDIRS = NO + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# Possible values are: Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese- +# Traditional, Croatian, Czech, Danish, Dutch, English, Esperanto, Farsi, +# Finnish, French, German, Greek, Hungarian, Italian, Japanese, Japanese-en, +# Korean, Korean-en, Latvian, Norwegian, Macedonian, Persian, Polish, +# Portuguese, Romanian, Russian, Serbian, Slovak, Slovene, Spanish, Swedish, +# Turkish, Ukrainian and Vietnamese. +# The default value is: English. + +OUTPUT_LANGUAGE = English + +# If the BRIEF_MEMBER_DESC tag is set to YES doxygen will include brief member +# descriptions after the members that are listed in the file and class +# documentation (similar to Javadoc). Set to NO to disable this. +# The default value is: YES. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES doxygen will prepend the brief +# description of a member or function before the detailed description +# +# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. +# The default value is: YES. + +REPEAT_BRIEF = YES + +# This tag implements a quasi-intelligent brief description abbreviator that is +# used to form the text in various listings. Each string in this list, if found +# as the leading text of the brief description, will be stripped from the text +# and the result, after processing the whole list, is used as the annotated +# text. Otherwise, the brief description is used as-is. If left blank, the +# following values are used ($name is automatically replaced with the name of +# the entity):The $name class, The $name widget, The $name file, is, provides, +# specifies, contains, represents, a, an and the. + +ABBREVIATE_BRIEF = "The $name class" \ + "The $name widget" \ + "The $name file" \ + is \ + provides \ + specifies \ + contains \ + represents \ + a \ + an \ + the + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# doxygen will generate a detailed section even if there is only a brief +# description. +# The default value is: NO. + +ALWAYS_DETAILED_SEC = NO + +# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all +# inherited members of a class in the documentation of that class as if those +# members were ordinary class members. Constructors, destructors and assignment +# operators of the base classes will not be shown. +# The default value is: NO. + +INLINE_INHERITED_MEMB = NO + +# If the FULL_PATH_NAMES tag is set to YES doxygen will prepend the full path +# before files name in the file list and in the header files. If set to NO the +# shortest path that makes the file name unique will be used +# The default value is: YES. + +FULL_PATH_NAMES = YES + +# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path. +# Stripping is only done if one of the specified strings matches the left-hand +# part of the path. The tag can be used to show relative paths in the file list. +# If left blank the directory from which doxygen is run is used as the path to +# strip. +# +# Note that you can specify absolute paths here, but also relative paths, which +# will be relative from the directory where doxygen is started. +# This tag requires that the tag FULL_PATH_NAMES is set to YES. + +STRIP_FROM_PATH = %TOPDIR% + +# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the +# path mentioned in the documentation of a class, which tells the reader which +# header file to include in order to use a class. If left blank only the name of +# the header file containing the class definition is used. Otherwise one should +# specify the list of include paths that are normally passed to the compiler +# using the -I flag. + +STRIP_FROM_INC_PATH = %TOPDIR%/include + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but +# less readable) file names. This can be useful is your file systems doesn't +# support long names like on DOS, Mac, or CD-ROM. +# The default value is: NO. + +SHORT_NAMES = NO + +# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the +# first line (until the first dot) of a Javadoc-style comment as the brief +# description. If set to NO, the Javadoc-style will behave just like regular Qt- +# style comments (thus requiring an explicit @brief command for a brief +# description.) +# The default value is: NO. + +JAVADOC_AUTOBRIEF = YES + +# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first +# line (until the first dot) of a Qt-style comment as the brief description. If +# set to NO, the Qt-style will behave just like regular Qt-style comments (thus +# requiring an explicit \brief command for a brief description.) +# The default value is: NO. + +QT_AUTOBRIEF = NO + +# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a +# multi-line C++ special comment block (i.e. a block of //! or /// comments) as +# a brief description. This used to be the default behavior. The new default is +# to treat a multi-line C++ comment block as a detailed description. Set this +# tag to YES if you prefer the old behavior instead. +# +# Note that setting this tag to YES also means that rational rose comments are +# not recognized any more. +# The default value is: NO. + +MULTILINE_CPP_IS_BRIEF = NO + +# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the +# documentation from any documented member that it re-implements. +# The default value is: YES. + +INHERIT_DOCS = YES + +# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce a +# new page for each member. If set to NO, the documentation of a member will be +# part of the file/class/namespace that contains it. +# The default value is: NO. + +SEPARATE_MEMBER_PAGES = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen +# uses this value to replace tabs by spaces in code fragments. +# Minimum value: 1, maximum value: 16, default value: 4. + +TAB_SIZE = 3 + +# This tag can be used to specify a number of aliases that act as commands in +# the documentation. An alias has the form: +# name=value +# For example adding +# "sideeffect=@par Side Effects:\n" +# will allow you to put the command \sideeffect (or @sideeffect) in the +# documentation, which will result in a user-defined paragraph with heading +# "Side Effects:". You can put \n's in the value part of an alias to insert +# newlines. + +ALIASES = "testCaseSetup=\link CppUT::TestCase::setUp() setUp()\endlink" \ + "testCaseRun=\link CppUT::TestCase::run() run()\endlink" \ + "testCaseTearDown=\link CppUT::TestCase::tearDown() tearDown()\endlink" \ + "json_ref=JSON (JavaScript Object Notation)" + +# This tag can be used to specify a number of word-keyword mappings (TCL only). +# A mapping has the form "name=value". For example adding "class=itcl::class" +# will allow you to use the command class in the itcl::class meaning. + +TCL_SUBST = + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources +# only. Doxygen will then generate output that is more tailored for C. For +# instance, some of the names that are used will be different. The list of all +# members will be omitted, etc. +# The default value is: NO. + +OPTIMIZE_OUTPUT_FOR_C = NO + +# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or +# Python sources only. Doxygen will then generate output that is more tailored +# for that language. For instance, namespaces will be presented as packages, +# qualified scopes will look different, etc. +# The default value is: NO. + +OPTIMIZE_OUTPUT_JAVA = NO + +# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran +# sources. Doxygen will then generate output that is tailored for Fortran. +# The default value is: NO. + +OPTIMIZE_FOR_FORTRAN = NO + +# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL +# sources. Doxygen will then generate output that is tailored for VHDL. +# The default value is: NO. + +OPTIMIZE_OUTPUT_VHDL = NO + +# Doxygen selects the parser to use depending on the extension of the files it +# parses. With this tag you can assign which parser to use for a given +# extension. Doxygen has a built-in mapping, but you can override or extend it +# using this tag. The format is ext=language, where ext is a file extension, and +# language is one of the parsers supported by doxygen: IDL, Java, JavaScript, +# C#, C, C++, D, PHP, Objective-C, Python, Fortran, VHDL. For instance to make +# doxygen treat .inc files as Fortran files (default is PHP), and .f files as C +# (default is Fortran), use: inc=Fortran f=C. +# +# Note For files without extension you can use no_extension as a placeholder. +# +# Note that for custom extensions you also need to set FILE_PATTERNS otherwise +# the files are not read by doxygen. + +EXTENSION_MAPPING = + +# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments +# according to the Markdown format, which allows for more readable +# documentation. See http://daringfireball.net/projects/markdown/ for details. +# The output of markdown processing is further processed by doxygen, so you can +# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in +# case of backward compatibilities issues. +# The default value is: YES. + +MARKDOWN_SUPPORT = YES + +# When enabled doxygen tries to link words that correspond to documented +# classes, or namespaces to their corresponding documentation. Such a link can +# be prevented in individual cases by by putting a % sign in front of the word +# or globally by setting AUTOLINK_SUPPORT to NO. +# The default value is: YES. + +AUTOLINK_SUPPORT = YES + +# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want +# to include (a tag file for) the STL sources as input, then you should set this +# tag to YES in order to let doxygen match functions declarations and +# definitions whose arguments contain STL classes (e.g. func(std::string); +# versus func(std::string) {}). This also make the inheritance and collaboration +# diagrams that involve STL classes more complete and accurate. +# The default value is: NO. + +BUILTIN_STL_SUPPORT = YES + +# If you use Microsoft's C++/CLI language, you should set this option to YES to +# enable parsing support. +# The default value is: NO. + +CPP_CLI_SUPPORT = NO + +# Set the SIP_SUPPORT tag to YES if your project consists of sip (see: +# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen +# will parse them like normal C++ but will assume all classes use public instead +# of private inheritance when no explicit protection keyword is present. +# The default value is: NO. + +SIP_SUPPORT = NO + +# For Microsoft's IDL there are propget and propput attributes to indicate +# getter and setter methods for a property. Setting this option to YES will make +# doxygen to replace the get and set methods by a property in the documentation. +# This will only work if the methods are indeed getting or setting a simple +# type. If this is not the case, or you want to show the methods anyway, you +# should set this option to NO. +# The default value is: YES. + +IDL_PROPERTY_SUPPORT = YES + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES, then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. +# The default value is: NO. + +DISTRIBUTE_GROUP_DOC = NO + +# Set the SUBGROUPING tag to YES to allow class member groups of the same type +# (for instance a group of public functions) to be put as a subgroup of that +# type (e.g. under the Public Functions section). Set it to NO to prevent +# subgrouping. Alternatively, this can be done per class using the +# \nosubgrouping command. +# The default value is: YES. + +SUBGROUPING = YES + +# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions +# are shown inside the group in which they are included (e.g. using \ingroup) +# instead of on a separate page (for HTML and Man pages) or section (for LaTeX +# and RTF). +# +# Note that this feature does not work in combination with +# SEPARATE_MEMBER_PAGES. +# The default value is: NO. + +INLINE_GROUPED_CLASSES = NO + +# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions +# with only public data fields or simple typedef fields will be shown inline in +# the documentation of the scope in which they are defined (i.e. file, +# namespace, or group documentation), provided this scope is documented. If set +# to NO, structs, classes, and unions are shown on a separate page (for HTML and +# Man pages) or section (for LaTeX and RTF). +# The default value is: NO. + +INLINE_SIMPLE_STRUCTS = NO + +# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or +# enum is documented as struct, union, or enum with the name of the typedef. So +# typedef struct TypeS {} TypeT, will appear in the documentation as a struct +# with name TypeT. When disabled the typedef will appear as a member of a file, +# namespace, or class. And the struct will be named TypeS. This can typically be +# useful for C code in case the coding convention dictates that all compound +# types are typedef'ed and only the typedef is referenced, never the tag name. +# The default value is: NO. + +TYPEDEF_HIDES_STRUCT = NO + +# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This +# cache is used to resolve symbols given their name and scope. Since this can be +# an expensive process and often the same symbol appears multiple times in the +# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small +# doxygen will become slower. If the cache is too large, memory is wasted. The +# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range +# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536 +# symbols. At the end of a run doxygen will report the cache usage and suggest +# the optimal cache size from a speed point of view. +# Minimum value: 0, maximum value: 9, default value: 0. + +LOOKUP_CACHE_SIZE = 0 + +#--------------------------------------------------------------------------- +# Build related configuration options +#--------------------------------------------------------------------------- + +# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in +# documentation are documented, even if no documentation was available. Private +# class members and static file members will be hidden unless the +# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES. +# Note: This will also disable the warnings about undocumented members that are +# normally produced when WARNINGS is set to YES. +# The default value is: NO. + +EXTRACT_ALL = YES + +# If the EXTRACT_PRIVATE tag is set to YES all private members of a class will +# be included in the documentation. +# The default value is: NO. + +EXTRACT_PRIVATE = NO + +# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal +# scope will be included in the documentation. +# The default value is: NO. + +EXTRACT_PACKAGE = NO + +# If the EXTRACT_STATIC tag is set to YES all static members of a file will be +# included in the documentation. +# The default value is: NO. + +EXTRACT_STATIC = YES + +# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) defined +# locally in source files will be included in the documentation. If set to NO +# only classes defined in header files are included. Does not have any effect +# for Java sources. +# The default value is: YES. + +EXTRACT_LOCAL_CLASSES = NO + +# This flag is only useful for Objective-C code. When set to YES local methods, +# which are defined in the implementation section but not in the interface are +# included in the documentation. If set to NO only methods in the interface are +# included. +# The default value is: NO. + +EXTRACT_LOCAL_METHODS = NO + +# If this flag is set to YES, the members of anonymous namespaces will be +# extracted and appear in the documentation as a namespace called +# 'anonymous_namespace{file}', where file will be replaced with the base name of +# the file that contains the anonymous namespace. By default anonymous namespace +# are hidden. +# The default value is: NO. + +EXTRACT_ANON_NSPACES = NO + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all +# undocumented members inside documented classes or files. If set to NO these +# members will be included in the various overviews, but no documentation +# section is generated. This option has no effect if EXTRACT_ALL is enabled. +# The default value is: NO. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. If set +# to NO these classes will be included in the various overviews. This option has +# no effect if EXTRACT_ALL is enabled. +# The default value is: NO. + +HIDE_UNDOC_CLASSES = NO + +# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend +# (class|struct|union) declarations. If set to NO these declarations will be +# included in the documentation. +# The default value is: NO. + +HIDE_FRIEND_COMPOUNDS = NO + +# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any +# documentation blocks found inside the body of a function. If set to NO these +# blocks will be appended to the function's detailed documentation block. +# The default value is: NO. + +HIDE_IN_BODY_DOCS = NO + +# The INTERNAL_DOCS tag determines if documentation that is typed after a +# \internal command is included. If the tag is set to NO then the documentation +# will be excluded. Set it to YES to include the internal documentation. +# The default value is: NO. + +INTERNAL_DOCS = YES + +# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file +# names in lower-case letters. If set to YES upper-case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# and Mac users are advised to set this option to NO. +# The default value is: system dependent. + +CASE_SENSE_NAMES = NO + +# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with +# their full class and namespace scopes in the documentation. If set to YES the +# scope will be hidden. +# The default value is: NO. + +HIDE_SCOPE_NAMES = NO + +# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of +# the files that are included by a file in the documentation of that file. +# The default value is: YES. + +SHOW_INCLUDE_FILES = YES + +# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include +# files with double quotes in the documentation rather than with sharp brackets. +# The default value is: NO. + +FORCE_LOCAL_INCLUDES = NO + +# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the +# documentation for inline members. +# The default value is: YES. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the +# (detailed) documentation of file and class members alphabetically by member +# name. If set to NO the members will appear in declaration order. +# The default value is: YES. + +SORT_MEMBER_DOCS = YES + +# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief +# descriptions of file, namespace and class members alphabetically by member +# name. If set to NO the members will appear in declaration order. +# The default value is: NO. + +SORT_BRIEF_DOCS = NO + +# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the +# (brief and detailed) documentation of class members so that constructors and +# destructors are listed first. If set to NO the constructors will appear in the +# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS. +# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief +# member documentation. +# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting +# detailed member documentation. +# The default value is: NO. + +SORT_MEMBERS_CTORS_1ST = NO + +# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy +# of group names into alphabetical order. If set to NO the group names will +# appear in their defined order. +# The default value is: NO. + +SORT_GROUP_NAMES = NO + +# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by +# fully-qualified names, including namespaces. If set to NO, the class list will +# be sorted only by class name, not including the namespace part. +# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. +# Note: This option applies only to the class list, not to the alphabetical +# list. +# The default value is: NO. + +SORT_BY_SCOPE_NAME = YES + +# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper +# type resolution of all parameters of a function it will reject a match between +# the prototype and the implementation of a member function even if there is +# only one candidate or it is obvious which candidate to choose by doing a +# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still +# accept a match between prototype and implementation in such cases. +# The default value is: NO. + +STRICT_PROTO_MATCHING = NO + +# The GENERATE_TODOLIST tag can be used to enable ( YES) or disable ( NO) the +# todo list. This list is created by putting \todo commands in the +# documentation. +# The default value is: YES. + +GENERATE_TODOLIST = YES + +# The GENERATE_TESTLIST tag can be used to enable ( YES) or disable ( NO) the +# test list. This list is created by putting \test commands in the +# documentation. +# The default value is: YES. + +GENERATE_TESTLIST = NO + +# The GENERATE_BUGLIST tag can be used to enable ( YES) or disable ( NO) the bug +# list. This list is created by putting \bug commands in the documentation. +# The default value is: YES. + +GENERATE_BUGLIST = NO + +# The GENERATE_DEPRECATEDLIST tag can be used to enable ( YES) or disable ( NO) +# the deprecated list. This list is created by putting \deprecated commands in +# the documentation. +# The default value is: YES. + +GENERATE_DEPRECATEDLIST= YES + +# The ENABLED_SECTIONS tag can be used to enable conditional documentation +# sections, marked by \if ... \endif and \cond +# ... \endcond blocks. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the +# initial value of a variable or macro / define can have for it to appear in the +# documentation. If the initializer consists of more lines than specified here +# it will be hidden. Use a value of 0 to hide initializers completely. The +# appearance of the value of individual variables and macros / defines can be +# controlled using \showinitializer or \hideinitializer command in the +# documentation regardless of this setting. +# Minimum value: 0, maximum value: 10000, default value: 30. + +MAX_INITIALIZER_LINES = 30 + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at +# the bottom of the documentation of classes and structs. If set to YES the list +# will mention the files that were used to generate the documentation. +# The default value is: YES. + +SHOW_USED_FILES = YES + +# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This +# will remove the Files entry from the Quick Index and from the Folder Tree View +# (if specified). +# The default value is: YES. + +SHOW_FILES = YES + +# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces +# page. This will remove the Namespaces entry from the Quick Index and from the +# Folder Tree View (if specified). +# The default value is: YES. + +SHOW_NAMESPACES = YES + +# The FILE_VERSION_FILTER tag can be used to specify a program or script that +# doxygen should invoke to get the current version for each file (typically from +# the version control system). Doxygen will invoke the program by executing (via +# popen()) the command command input-file, where command is the value of the +# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided +# by doxygen. Whatever the program writes to standard output is used as the file +# version. For an example see the documentation. + +FILE_VERSION_FILTER = + +# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed +# by doxygen. The layout file controls the global structure of the generated +# output files in an output format independent way. To create the layout file +# that represents doxygen's defaults, run doxygen with the -l option. You can +# optionally specify a file name after the option, if omitted DoxygenLayout.xml +# will be used as the name of the layout file. +# +# Note that if you run doxygen from a directory containing a file called +# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE +# tag is left empty. + +LAYOUT_FILE = + +# The CITE_BIB_FILES tag can be used to specify one or more bib files containing +# the reference definitions. This must be a list of .bib files. The .bib +# extension is automatically appended if omitted. This requires the bibtex tool +# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info. +# For LaTeX the style of the bibliography can be controlled using +# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the +# search path. Do not use file names with spaces, bibtex cannot handle them. See +# also \cite for info how to create references. + +CITE_BIB_FILES = + +#--------------------------------------------------------------------------- +# Configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated to +# standard output by doxygen. If QUIET is set to YES this implies that the +# messages are off. +# The default value is: NO. + +QUIET = NO + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated to standard error ( stderr) by doxygen. If WARNINGS is set to YES +# this implies that the warnings are on. +# +# Tip: Turn warnings on while writing the documentation. +# The default value is: YES. + +WARNINGS = YES + +# If the WARN_IF_UNDOCUMENTED tag is set to YES, then doxygen will generate +# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag +# will automatically be disabled. +# The default value is: YES. + +WARN_IF_UNDOCUMENTED = YES + +# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for +# potential errors in the documentation, such as not documenting some parameters +# in a documented function, or documenting parameters that don't exist or using +# markup commands wrongly. +# The default value is: YES. + +WARN_IF_DOC_ERROR = YES + +# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that +# are documented, but have no documentation for their parameters or return +# value. If set to NO doxygen will only warn about wrong or incomplete parameter +# documentation, but not about the absence of documentation. +# The default value is: NO. + +WARN_NO_PARAMDOC = NO + +# The WARN_FORMAT tag determines the format of the warning messages that doxygen +# can produce. The string should contain the $file, $line, and $text tags, which +# will be replaced by the file and line number from which the warning originated +# and the warning text. Optionally the format may contain $version, which will +# be replaced by the version of the file (if it could be obtained via +# FILE_VERSION_FILTER) +# The default value is: $file:$line: $text. + +WARN_FORMAT = "$file:$line: $text" + +# The WARN_LOGFILE tag can be used to specify a file to which warning and error +# messages should be written. If left blank the output is written to standard +# error (stderr). + +WARN_LOGFILE = %WARNING_LOG_PATH% + +#--------------------------------------------------------------------------- +# Configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag is used to specify the files and/or directories that contain +# documented source files. You may enter file names like myfile.cpp or +# directories like /usr/src/myproject. Separate the files or directories with +# spaces. +# Note: If this tag is empty the current directory is searched. + +INPUT = ../include \ + ../src/lib_json \ + . + +# This tag can be used to specify the character encoding of the source files +# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses +# libiconv (or the iconv built into libc) for the transcoding. See the libiconv +# documentation (see: http://www.gnu.org/software/libiconv) for the list of +# possible encodings. +# The default value is: UTF-8. + +INPUT_ENCODING = UTF-8 + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and +# *.h) to filter out the source-files in the directories. If left blank the +# following patterns are tested:*.c, *.cc, *.cxx, *.cpp, *.c++, *.java, *.ii, +# *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp, +# *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown, +# *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf, +# *.qsf, *.as and *.js. + +FILE_PATTERNS = *.h \ + *.cpp \ + *.inl \ + *.dox + +# The RECURSIVE tag can be used to specify whether or not subdirectories should +# be searched for input files as well. +# The default value is: NO. + +RECURSIVE = YES + +# The EXCLUDE tag can be used to specify files and/or directories that should be +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. +# +# Note that relative paths are relative to the directory from which doxygen is +# run. + +EXCLUDE = + +# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or +# directories that are symbolic links (a Unix file system feature) are excluded +# from the input. +# The default value is: NO. + +EXCLUDE_SYMLINKS = NO + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. +# +# Note that the wildcards are matched against the file with absolute path, so to +# exclude all test directories for example use the pattern */test/* + +EXCLUDE_PATTERNS = + +# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names +# (namespaces, classes, functions, etc.) that should be excluded from the +# output. The symbol name can be a fully qualified name, a word, or if the +# wildcard * is used, a substring. Examples: ANamespace, AClass, +# AClass::ANamespace, ANamespace::*Test +# +# Note that the wildcards are matched against the file with absolute path, so to +# exclude all test directories use the pattern */test/* + +EXCLUDE_SYMBOLS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or directories +# that contain example code fragments that are included (see the \include +# command). + +EXAMPLE_PATH = .. + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and +# *.h) to filter out the source-files in the directories. If left blank all +# files are included. + +EXAMPLE_PATTERNS = * + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude commands +# irrespective of the value of the RECURSIVE tag. +# The default value is: NO. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or directories +# that contain images that are to be included in the documentation (see the +# \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command: +# +# +# +# where is the value of the INPUT_FILTER tag, and is the +# name of an input file. Doxygen will then use the output that the filter +# program writes to standard output. If FILTER_PATTERNS is specified, this tag +# will be ignored. +# +# Note that the filter must not add or remove lines; it is applied before the +# code is scanned, but not when the output code is generated. If lines are added +# or removed, the anchors will not be placed correctly. + +INPUT_FILTER = + +# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern +# basis. Doxygen will compare the file name with each pattern and apply the +# filter if there is a match. The filters are a list of the form: pattern=filter +# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how +# filters are used. If the FILTER_PATTERNS tag is empty or if none of the +# patterns match the file name, INPUT_FILTER is applied. + +FILTER_PATTERNS = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER ) will also be used to filter the input files that are used for +# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES). +# The default value is: NO. + +FILTER_SOURCE_FILES = NO + +# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file +# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and +# it is also possible to disable source filtering for a specific pattern using +# *.ext= (so without naming a filter). +# This tag requires that the tag FILTER_SOURCE_FILES is set to YES. + +FILTER_SOURCE_PATTERNS = + +# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that +# is part of the input, its contents will be placed on the main page +# (index.html). This can be useful if you have a project on for instance GitHub +# and want to reuse the introduction page also for the doxygen output. + +USE_MDFILE_AS_MAINPAGE = + +#--------------------------------------------------------------------------- +# Configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will be +# generated. Documented entities will be cross-referenced with these sources. +# +# Note: To get rid of all source code in the generated output, make sure that +# also VERBATIM_HEADERS is set to NO. +# The default value is: NO. + +SOURCE_BROWSER = YES + +# Setting the INLINE_SOURCES tag to YES will include the body of functions, +# classes and enums directly into the documentation. +# The default value is: NO. + +INLINE_SOURCES = NO + +# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any +# special comment blocks from generated source code fragments. Normal C, C++ and +# Fortran comments will always remain visible. +# The default value is: YES. + +STRIP_CODE_COMMENTS = YES + +# If the REFERENCED_BY_RELATION tag is set to YES then for each documented +# function all documented functions referencing it will be listed. +# The default value is: NO. + +REFERENCED_BY_RELATION = YES + +# If the REFERENCES_RELATION tag is set to YES then for each documented function +# all documented entities called/used by that function will be listed. +# The default value is: NO. + +REFERENCES_RELATION = YES + +# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set +# to YES, then the hyperlinks from functions in REFERENCES_RELATION and +# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will +# link to the documentation. +# The default value is: YES. + +REFERENCES_LINK_SOURCE = YES + +# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the +# source code will show a tooltip with additional information such as prototype, +# brief description and links to the definition and documentation. Since this +# will make the HTML file larger and loading of large files a bit slower, you +# can opt to disable this feature. +# The default value is: YES. +# This tag requires that the tag SOURCE_BROWSER is set to YES. + +SOURCE_TOOLTIPS = YES + +# If the USE_HTAGS tag is set to YES then the references to source code will +# point to the HTML generated by the htags(1) tool instead of doxygen built-in +# source browser. The htags tool is part of GNU's global source tagging system +# (see http://www.gnu.org/software/global/global.html). You will need version +# 4.8.6 or higher. +# +# To use it do the following: +# - Install the latest version of global +# - Enable SOURCE_BROWSER and USE_HTAGS in the config file +# - Make sure the INPUT points to the root of the source tree +# - Run doxygen as normal +# +# Doxygen will invoke htags (and that will in turn invoke gtags), so these +# tools must be available from the command line (i.e. in the search path). +# +# The result: instead of the source browser generated by doxygen, the links to +# source code will now point to the output of htags. +# The default value is: NO. +# This tag requires that the tag SOURCE_BROWSER is set to YES. + +USE_HTAGS = NO + +# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a +# verbatim copy of the header file for each class for which an include is +# specified. Set to NO to disable this. +# See also: Section \class. +# The default value is: YES. + +VERBATIM_HEADERS = YES + +#--------------------------------------------------------------------------- +# Configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all +# compounds will be generated. Enable this if the project contains a lot of +# classes, structs, unions or interfaces. +# The default value is: YES. + +ALPHABETICAL_INDEX = YES +TOC_INCLUDE_HEADINGS = 2 + +# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in +# which the alphabetical index list will be split. +# Minimum value: 1, maximum value: 20, default value: 5. +# This tag requires that the tag ALPHABETICAL_INDEX is set to YES. + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all classes will +# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag +# can be used to specify a prefix (or a list of prefixes) that should be ignored +# while generating the index headers. +# This tag requires that the tag ALPHABETICAL_INDEX is set to YES. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# Configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES doxygen will generate HTML output +# The default value is: YES. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a +# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of +# it. +# The default directory is: html. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_OUTPUT = %HTML_OUTPUT% + +# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each +# generated HTML page (for example: .htm, .php, .asp). +# The default value is: .html. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_FILE_EXTENSION = .html + +# The HTML_HEADER tag can be used to specify a user-defined HTML header file for +# each generated HTML page. If the tag is left blank doxygen will generate a +# standard header. +# +# To get valid HTML the header file that includes any scripts and style sheets +# that doxygen needs, which is dependent on the configuration options used (e.g. +# the setting GENERATE_TREEVIEW). It is highly recommended to start with a +# default header using +# doxygen -w html new_header.html new_footer.html new_stylesheet.css +# YourConfigFile +# and then modify the file new_header.html. See also section "Doxygen usage" +# for information on how to generate the default header that doxygen normally +# uses. +# Note: The header is subject to change so you typically have to regenerate the +# default header when upgrading to a newer version of doxygen. For a description +# of the possible markers and block names see the documentation. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_HEADER = header.html + +# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each +# generated HTML page. If the tag is left blank doxygen will generate a standard +# footer. See HTML_HEADER for more information on how to generate a default +# footer and what special commands can be used inside the footer. See also +# section "Doxygen usage" for information on how to generate the default footer +# that doxygen normally uses. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_FOOTER = footer.html + +# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style +# sheet that is used by each HTML page. It can be used to fine-tune the look of +# the HTML output. If left blank doxygen will generate a default style sheet. +# See also section "Doxygen usage" for information on how to generate the style +# sheet that doxygen normally uses. +# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as +# it is more robust and this tag (HTML_STYLESHEET) will in the future become +# obsolete. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_STYLESHEET = + +# The HTML_EXTRA_STYLESHEET tag can be used to specify an additional user- +# defined cascading style sheet that is included after the standard style sheets +# created by doxygen. Using this option one can overrule certain style aspects. +# This is preferred over using HTML_STYLESHEET since it does not replace the +# standard style sheet and is therefore more robust against future updates. +# Doxygen will copy the style sheet file to the output directory. For an example +# see the documentation. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_EXTRA_STYLESHEET = + +# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or +# other source files which should be copied to the HTML output directory. Note +# that these files will be copied to the base HTML output directory. Use the +# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these +# files. In the HTML_STYLESHEET file, use the file name only. Also note that the +# files will be copied as-is; there are no commands or markers available. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_EXTRA_FILES = + +# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen +# will adjust the colors in the stylesheet and background images according to +# this color. Hue is specified as an angle on a colorwheel, see +# http://en.wikipedia.org/wiki/Hue for more information. For instance the value +# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300 +# purple, and 360 is red again. +# Minimum value: 0, maximum value: 359, default value: 220. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_HUE = 220 + +# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors +# in the HTML output. For a value of 0 the output will use grayscales only. A +# value of 255 will produce the most vivid colors. +# Minimum value: 0, maximum value: 255, default value: 100. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_SAT = 100 + +# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the +# luminance component of the colors in the HTML output. Values below 100 +# gradually make the output lighter, whereas values above 100 make the output +# darker. The value divided by 100 is the actual gamma applied, so 80 represents +# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not +# change the gamma. +# Minimum value: 40, maximum value: 240, default value: 80. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_GAMMA = 80 + +# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML +# page will contain the date and time when the page was generated. Setting this +# to NO can help when comparing the output of multiple runs. +# The default value is: YES. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_TIMESTAMP = YES + +# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML +# documentation will contain sections that can be hidden and shown after the +# page has loaded. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_DYNAMIC_SECTIONS = YES + +# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries +# shown in the various tree structured indices initially; the user can expand +# and collapse entries dynamically later on. Doxygen will expand the tree to +# such a level that at most the specified number of entries are visible (unless +# a fully collapsed tree already exceeds this amount). So setting the number of +# entries 1 will produce a full collapsed tree by default. 0 is a special value +# representing an infinite number of entries and will result in a full expanded +# tree by default. +# Minimum value: 0, maximum value: 9999, default value: 100. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_INDEX_NUM_ENTRIES = 100 + +# If the GENERATE_DOCSET tag is set to YES, additional index files will be +# generated that can be used as input for Apple's Xcode 3 integrated development +# environment (see: http://developer.apple.com/tools/xcode/), introduced with +# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a +# Makefile in the HTML output directory. Running make will produce the docset in +# that directory and running make install will install the docset in +# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at +# startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html +# for more information. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_DOCSET = NO + +# This tag determines the name of the docset feed. A documentation feed provides +# an umbrella under which multiple documentation sets from a single provider +# (such as a company or product suite) can be grouped. +# The default value is: Doxygen generated docs. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_FEEDNAME = "Doxygen generated docs" + +# This tag specifies a string that should uniquely identify the documentation +# set bundle. This should be a reverse domain-name style string, e.g. +# com.mycompany.MyDocSet. Doxygen will append .docset to the name. +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_BUNDLE_ID = org.doxygen.Project + +# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify +# the documentation publisher. This should be a reverse domain-name style +# string, e.g. com.mycompany.MyDocSet.documentation. +# The default value is: org.doxygen.Publisher. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_PUBLISHER_ID = org.doxygen.Publisher + +# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher. +# The default value is: Publisher. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_PUBLISHER_NAME = Publisher + +# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three +# additional HTML index files: index.hhp, index.hhc, and index.hhk. The +# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop +# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on +# Windows. +# +# The HTML Help Workshop contains a compiler that can convert all HTML output +# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML +# files are now used as the Windows 98 help format, and will replace the old +# Windows help format (.hlp) on all Windows platforms in the future. Compressed +# HTML files also contain an index, a table of contents, and you can search for +# words in the documentation. The HTML workshop also contains a viewer for +# compressed HTML files. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_HTMLHELP = %HTML_HELP% + +# The CHM_FILE tag can be used to specify the file name of the resulting .chm +# file. You can add a path in front of the file if the result should not be +# written to the html output directory. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +CHM_FILE = jsoncpp-%JSONCPP_VERSION%.chm + +# The HHC_LOCATION tag can be used to specify the location (absolute path +# including file name) of the HTML help compiler ( hhc.exe). If non-empty +# doxygen will try to run the HTML help compiler on the generated index.hhp. +# The file has to be specified with full path. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +HHC_LOCATION = "c:\Program Files\HTML Help Workshop\hhc.exe" + +# The GENERATE_CHI flag controls if a separate .chi index file is generated ( +# YES) or that it should be included in the master .chm file ( NO). +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +GENERATE_CHI = YES + +# The CHM_INDEX_ENCODING is used to encode HtmlHelp index ( hhk), content ( hhc) +# and project file content. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +CHM_INDEX_ENCODING = + +# The BINARY_TOC flag controls whether a binary table of contents is generated ( +# YES) or a normal table of contents ( NO) in the .chm file. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +BINARY_TOC = YES + +# The TOC_EXPAND flag can be set to YES to add extra items for group members to +# the table of contents of the HTML help documentation and to the tree view. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +TOC_EXPAND = YES + +# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and +# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that +# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help +# (.qch) of the generated HTML documentation. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_QHP = NO + +# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify +# the file name of the resulting .qch file. The path specified is relative to +# the HTML output folder. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QCH_FILE = + +# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help +# Project output. For more information please see Qt Help Project / Namespace +# (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace). +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_NAMESPACE = + +# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt +# Help Project output. For more information please see Qt Help Project / Virtual +# Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual- +# folders). +# The default value is: doc. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_VIRTUAL_FOLDER = doc + +# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom +# filter to add. For more information please see Qt Help Project / Custom +# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- +# filters). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_CUST_FILTER_NAME = + +# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the +# custom filter to add. For more information please see Qt Help Project / Custom +# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- +# filters). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_CUST_FILTER_ATTRS = + +# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this +# project's filter section matches. Qt Help Project / Filter Attributes (see: +# http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_SECT_FILTER_ATTRS = + +# The QHG_LOCATION tag can be used to specify the location of Qt's +# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the +# generated .qhp file. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHG_LOCATION = + +# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be +# generated, together with the HTML files, they form an Eclipse help plugin. To +# install this plugin and make it available under the help contents menu in +# Eclipse, the contents of the directory containing the HTML and XML files needs +# to be copied into the plugins directory of eclipse. The name of the directory +# within the plugins directory should be the same as the ECLIPSE_DOC_ID value. +# After copying Eclipse needs to be restarted before the help appears. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_ECLIPSEHELP = NO + +# A unique identifier for the Eclipse help plugin. When installing the plugin +# the directory name containing the HTML and XML files should also have this +# name. Each documentation set should have its own identifier. +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES. + +ECLIPSE_DOC_ID = org.doxygen.Project + +# If you want full control over the layout of the generated HTML pages it might +# be necessary to disable the index and replace it with your own. The +# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top +# of each HTML page. A value of NO enables the index and the value YES disables +# it. Since the tabs in the index contain the same information as the navigation +# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +DISABLE_INDEX = NO + +# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index +# structure should be generated to display hierarchical information. If the tag +# value is set to YES, a side panel will be generated containing a tree-like +# index structure (just like the one that is generated for HTML Help). For this +# to work a browser that supports JavaScript, DHTML, CSS and frames is required +# (i.e. any modern browser). Windows users are probably better off using the +# HTML help feature. Via custom stylesheets (see HTML_EXTRA_STYLESHEET) one can +# further fine-tune the look of the index. As an example, the default style +# sheet generated by doxygen has an example that shows how to put an image at +# the root of the tree instead of the PROJECT_NAME. Since the tree basically has +# the same information as the tab index, you could consider setting +# DISABLE_INDEX to YES when enabling this option. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_TREEVIEW = NO + +# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that +# doxygen will group on one line in the generated HTML documentation. +# +# Note that a value of 0 will completely suppress the enum values from appearing +# in the overview section. +# Minimum value: 0, maximum value: 20, default value: 4. +# This tag requires that the tag GENERATE_HTML is set to YES. + +ENUM_VALUES_PER_LINE = 4 + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used +# to set the initial width (in pixels) of the frame in which the tree is shown. +# Minimum value: 0, maximum value: 1500, default value: 250. +# This tag requires that the tag GENERATE_HTML is set to YES. + +TREEVIEW_WIDTH = 250 + +# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open links to +# external symbols imported via tag files in a separate window. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +EXT_LINKS_IN_WINDOW = NO + +# Use this tag to change the font size of LaTeX formulas included as images in +# the HTML documentation. When you change the font size after a successful +# doxygen run you need to manually remove any form_*.png images from the HTML +# output directory to force them to be regenerated. +# Minimum value: 8, maximum value: 50, default value: 10. +# This tag requires that the tag GENERATE_HTML is set to YES. + +FORMULA_FONTSIZE = 10 + +# Use the FORMULA_TRANPARENT tag to determine whether or not the images +# generated for formulas are transparent PNGs. Transparent PNGs are not +# supported properly for IE 6.0, but are supported on all modern browsers. +# +# Note that when changing this option you need to delete any form_*.png files in +# the HTML output directory before the changes have effect. +# The default value is: YES. +# This tag requires that the tag GENERATE_HTML is set to YES. + +FORMULA_TRANSPARENT = YES + +# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see +# http://www.mathjax.org) which uses client side JavaScript for the rendering +# instead of using prerendered bitmaps. Use this if you do not have LaTeX +# installed or if you want to formulas look prettier in the HTML output. When +# enabled you may also need to install MathJax separately and configure the path +# to it using the MATHJAX_RELPATH option. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +USE_MATHJAX = NO + +# When MathJax is enabled you can set the default output format to be used for +# the MathJax output. See the MathJax site (see: +# http://docs.mathjax.org/en/latest/output.html) for more details. +# Possible values are: HTML-CSS (which is slower, but has the best +# compatibility), NativeMML (i.e. MathML) and SVG. +# The default value is: HTML-CSS. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_FORMAT = HTML-CSS + +# When MathJax is enabled you need to specify the location relative to the HTML +# output directory using the MATHJAX_RELPATH option. The destination directory +# should contain the MathJax.js script. For instance, if the mathjax directory +# is located at the same level as the HTML output directory, then +# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax +# Content Delivery Network so you can quickly see the result without installing +# MathJax. However, it is strongly recommended to install a local copy of +# MathJax from http://www.mathjax.org before deployment. +# The default value is: http://cdn.mathjax.org/mathjax/latest. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest + +# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax +# extension names that should be enabled during MathJax rendering. For example +# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_EXTENSIONS = + +# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces +# of code that will be used on startup of the MathJax code. See the MathJax site +# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an +# example see the documentation. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_CODEFILE = + +# When the SEARCHENGINE tag is enabled doxygen will generate a search box for +# the HTML output. The underlying search engine uses javascript and DHTML and +# should work on any modern browser. Note that when using HTML help +# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET) +# there is already a search function so this one should typically be disabled. +# For large projects the javascript based search engine can be slow, then +# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to +# search using the keyboard; to jump to the search box use + S +# (what the is depends on the OS and browser, but it is typically +# , /