diff --git a/bin/win64/LICENSE b/bin/win64/LICENSE new file mode 100644 index 0000000..94a9ed0 --- /dev/null +++ b/bin/win64/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. 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 +them 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 prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. 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. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey 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; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If 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 convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU 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 that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + 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. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +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. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + 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 +state 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 3 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, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program 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, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU 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. But first, please read +. diff --git a/bin/win64/res/qml/UtilitiesPage.qml b/bin/win64/res/qml/UtilitiesPage.qml index 3eae765..2085c5a 100644 --- a/bin/win64/res/qml/UtilitiesPage.qml +++ b/bin/win64/res/qml/UtilitiesPage.qml @@ -12,6 +12,7 @@ MyStackViewPage { GroupBox { + id: keyboardGroupBox Layout.fillWidth: true label: MyText { @@ -43,8 +44,8 @@ MyStackViewPage { spacing: 18 MyPushButton { - text: "VR Keyboard Input" - Layout.preferredWidth: 260 + text: "Keyboard Input" + Layout.preferredWidth: 250 onClicked: { OverlayController.showKeyboard("", 601) } @@ -60,7 +61,7 @@ MyStackViewPage { MyPushButton { text: "Enter" - Layout.preferredWidth: 260 + Layout.preferredWidth: 250 onClicked: { UtilitiesTabController.sendKeyboardEnter() } @@ -68,7 +69,7 @@ MyStackViewPage { MyPushButton { text: "Backspace" - Layout.preferredWidth: 260 + Layout.preferredWidth: 250 onClicked: { UtilitiesTabController.sendKeyboardBackspace(1) } @@ -76,7 +77,7 @@ MyStackViewPage { MyPushButton { text: "10x Backspace" - Layout.preferredWidth: 260 + Layout.preferredWidth: 250 onClicked: { UtilitiesTabController.sendKeyboardBackspace(10) } @@ -85,14 +86,174 @@ MyStackViewPage { } } + + GroupBox { + id: alarmGroupBox + Layout.fillWidth: true + + label: MyText { + leftPadding: 10 + text: "Alarm Clock" + bottomPadding: -10 + } + background: Rectangle { + color: "transparent" + border.color: "#ffffff" + radius: 8 + } + ColumnLayout { + anchors.fill: parent + + Rectangle { + color: "#ffffff" + height: 1 + Layout.fillWidth: true + Layout.bottomMargin: 5 + } + + RowLayout { + MyToggleButton { + id: alarmClockToggle + text: "" + onCheckedChanged: { + UtilitiesTabController.setAlarmEnabled(checked, false) + } + } + + Item { + Layout.fillWidth: true + } + + MyTextField { + id: alarmClockHourText + text: "00" + keyBoardUID: 602 + Layout.preferredWidth: 50 + horizontalAlignment: Text.AlignHCenter + function onInputEvent(input) { + var val = parseInt(input) + if (!isNaN(val)) { + if (val < 0) { + val = 0 + } else if (val > 23) { + val = 23 + } + UtilitiesTabController.setAlarmTimeHour(val, false) + } + setAlarmHourText(UtilitiesTabController.alarmTimeHour) + } + } + + MyText { + text: ":" + } + + MyTextField { + id: alarmClockMinuteText + text: "00" + keyBoardUID: 603 + Layout.preferredWidth: 50 + horizontalAlignment: Text.AlignHCenter + function onInputEvent(input) { + var val = parseInt(input) + if (!isNaN(val)) { + if (val < 0) { + val = 0 + } else if (val > 59) { + val = 59 + } + UtilitiesTabController.setAlarmTimeMinute(val, false) + } + setAlarmMinuteText(UtilitiesTabController.alarmTimeMinute) + } + } + + Item { + Layout.fillWidth: true + } + + MyPushButton2 { + Layout.preferredWidth: 200 + text: "Current Time" + onClicked: { + UtilitiesTabController.setAlarmTimeToCurrentTime() + } + } + + MyPushButton2 { + Layout.leftMargin: 50 + Layout.preferredWidth: 120 + text: "+1 Hour" + onClicked: { + UtilitiesTabController.modAlarmTimeHour(1) + } + } + + MyPushButton2 { + Layout.preferredWidth: 120 + text: "-1 Hour" + onClicked: { + UtilitiesTabController.modAlarmTimeHour(-1) + } + } + + MyPushButton2 { + text: "+5 Min" + Layout.leftMargin: 50 + Layout.preferredWidth: 120 + onClicked: { + UtilitiesTabController.modAlarmTimeMinute(5) + } + } + + MyPushButton2 { + Layout.preferredWidth: 120 + text: "-5 Min" + onClicked: { + UtilitiesTabController.modAlarmTimeMinute(-5) + } + } + } + } + } + Item { Layout.fillHeight: true } - /*Component.onCompleted: { + Component.onCompleted: { + alarmClockToggle.checked = UtilitiesTabController.alarmEnabled + setAlarmHourText(UtilitiesTabController.alarmTimeHour) + setAlarmMinuteText(UtilitiesTabController.alarmTimeMinute) + alarmGroupBox.visible = !OverlayController.desktopMode + keyboardGroupBox.visible = !OverlayController.desktopMode } Connections { - }*/ + target: UtilitiesTabController + onAlarmEnabledChanged: { + alarmClockToggle.checked = UtilitiesTabController.alarmEnabled + } + onAlarmTimeHourChanged: { + setAlarmHourText(UtilitiesTabController.alarmTimeHour) + } + onAlarmTimeMinuteChanged: { + setAlarmMinuteText(UtilitiesTabController.alarmTimeMinute) + } + } + } + function setAlarmHourText(value) { + if (value < 9) { + alarmClockHourText.text = "0" + value + } else { + alarmClockHourText.text = value + } + } + function setAlarmMinuteText(value) { + if (value < 9) { + alarmClockMinuteText.text = "0" + value + } else { + alarmClockMinuteText.text = value + } } } diff --git a/src/overlaycontroller.cpp b/src/overlaycontroller.cpp index d6c61ca..bd410d1 100644 --- a/src/overlaycontroller.cpp +++ b/src/overlaycontroller.cpp @@ -250,9 +250,9 @@ void OverlayController::renderOverlay() { if (unTexture != 0) { #if defined _WIN64 || defined _LP64 // To avoid any compiler warning because of cast to a larger pointer type (warning C4312 on VC) - vr::Texture_t texture = { (void*)((uint64_t)unTexture), vr::API_OpenGL, vr::ColorSpace_Auto }; + vr::Texture_t texture = { (void*)((uint64_t)unTexture), vr::TextureType_OpenGL, vr::ColorSpace_Auto }; #else - vr::Texture_t texture = { (void*)unTexture, vr::API_OpenGL, vr::ColorSpace_Auto }; + vr::Texture_t texture = { (void*)unTexture, vr::TextureType_OpenGL, vr::ColorSpace_Auto }; #endif vr::VROverlay()->SetOverlayTexture(m_ulOverlayHandle, &texture); } @@ -282,6 +282,7 @@ void OverlayController::OnTimeoutPumpEvents() { settingsTabController.eventLoopTick(); reviveTabController.eventLoopTick(); audioTabController.eventLoopTick(); + utilitiesTabController.eventLoopTick(); vr::VREvent_t vrEvent; while (vr::VROverlay()->PollNextOverlayEvent(m_ulOverlayHandle, &vrEvent, sizeof(vrEvent))) { @@ -503,6 +504,16 @@ bool OverlayController::soundDisabled() { } +const vr::VROverlayHandle_t& OverlayController::overlayHandle() { + return m_ulOverlayHandle; +} + + +const vr::VROverlayHandle_t& OverlayController::overlayThumbnailHandle() { + return m_ulOverlayThumbnailHandle; +} + + void OverlayController::showKeyboard(QString existingText, unsigned long userValue) { vr::VROverlay()->ShowKeyboardForOverlay(m_ulOverlayHandle, vr::k_EGamepadTextInputModeNormal, vr::k_EGamepadTextInputLineModeSingleLine, "Advanced Settings Overlay", 1024, existingText.toStdString().c_str(), false, userValue); } diff --git a/src/overlaycontroller.h b/src/overlaycontroller.h index 5b29745..41cad09 100644 --- a/src/overlaycontroller.h +++ b/src/overlaycontroller.h @@ -106,6 +106,9 @@ public: Q_INVOKABLE bool soundDisabled(); + const vr::VROverlayHandle_t& overlayHandle(); + const vr::VROverlayHandle_t& overlayThumbnailHandle(); + public slots: void renderOverlay(); void OnRenderRequest(); diff --git a/src/tabcontrollers/AudioTabController.cpp b/src/tabcontrollers/AudioTabController.cpp index bdbcedd..5b414e4 100644 --- a/src/tabcontrollers/AudioTabController.cpp +++ b/src/tabcontrollers/AudioTabController.cpp @@ -410,7 +410,7 @@ namespace advsettings { auto leftId = vr::VRSystem()->GetTrackedDeviceIndexForControllerRole(vr::TrackedControllerRole_LeftHand); if (leftId != vr::k_unTrackedDeviceIndexInvalid) { vr::VRControllerState_t state; - if (vr::VRSystem()->GetControllerState(leftId, &state)) { + if (vr::VRSystem()->GetControllerState(leftId, &state, sizeof(vr::VRControllerState_t))) { //logControllerState(state, "Left "); newState |= handleControllerState(state, m_pttControllerConfigs); } @@ -420,7 +420,7 @@ namespace advsettings { auto rightId = vr::VRSystem()->GetTrackedDeviceIndexForControllerRole(vr::TrackedControllerRole_RightHand); if (rightId != vr::k_unTrackedDeviceIndexInvalid) { vr::VRControllerState_t state; - if (vr::VRSystem()->GetControllerState(rightId, &state)) { + if (vr::VRSystem()->GetControllerState(rightId, &state, sizeof(vr::VRControllerState_t))) { //logControllerState(state, "Right "); newState |= handleControllerState(state, m_pttControllerConfigs + 1); } diff --git a/src/tabcontrollers/SteamVRTabController.cpp b/src/tabcontrollers/SteamVRTabController.cpp index 5a10dff..a7f5ddc 100644 --- a/src/tabcontrollers/SteamVRTabController.cpp +++ b/src/tabcontrollers/SteamVRTabController.cpp @@ -44,14 +44,14 @@ void SteamVRTabController::eventLoopTick() { LOG(DEBUG) << "OpenVR reports a changed compositor supersampling value: " << m_compositorSuperSampling << " => " << css; setCompositorSuperSampling(css); } - auto air = vr::VRSettings()->GetBool(vr::k_pch_SteamVR_Section, vrsettings_steamvr_allowInterleavedReprojection, &vrSettingsError); + auto air = vr::VRSettings()->GetBool(vr::k_pch_SteamVR_Section, vr::k_pch_SteamVR_AllowReprojection_Bool, &vrSettingsError); if (vrSettingsError != vr::VRSettingsError_None) { - LOG(WARNING) << "Could not read \"" << vrsettings_steamvr_allowInterleavedReprojection << "\" setting: " << vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError); + LOG(WARNING) << "Could not read \"" << vr::k_pch_SteamVR_AllowReprojection_Bool << "\" setting: " << vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError); } setAllowInterleavedReprojection(air); - auto aar = vr::VRSettings()->GetBool(vr::k_pch_SteamVR_Section, vrsettings_steamvr_allowAsyncReprojection, &vrSettingsError); + auto aar = vr::VRSettings()->GetBool(vr::k_pch_SteamVR_Section, vr::k_pch_SteamVR_AllowAsyncReprojection_Bool, &vrSettingsError); if (vrSettingsError != vr::VRSettingsError_None) { - LOG(WARNING) << "Could not read \"" << vrsettings_steamvr_allowAsyncReprojection << "\" setting: " << vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError); + LOG(WARNING) << "Could not read \"" << vr::k_pch_SteamVR_AllowAsyncReprojection_Bool << "\" setting: " << vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError); } setAllowAsyncReprojection(aar); auto fr = vr::VRSettings()->GetBool(vr::k_pch_SteamVR_Section, vr::k_pch_SteamVR_ForceReprojection_Bool, &vrSettingsError); @@ -127,7 +127,7 @@ bool SteamVRTabController::allowAsyncReprojection() const { void SteamVRTabController::setAllowInterleavedReprojection(bool value, bool notify) { if (m_allowInterleavedReprojection != value) { m_allowInterleavedReprojection = value; - vr::VRSettings()->SetBool(vr::k_pch_SteamVR_Section, vrsettings_steamvr_allowInterleavedReprojection, m_allowInterleavedReprojection); + vr::VRSettings()->SetBool(vr::k_pch_SteamVR_Section, vr::k_pch_SteamVR_AllowReprojection_Bool, m_allowInterleavedReprojection); vr::VRSettings()->Sync(); if (notify) { emit allowInterleavedReprojectionChanged(m_allowInterleavedReprojection); @@ -139,7 +139,7 @@ void SteamVRTabController::setAllowInterleavedReprojection(bool value, bool noti void SteamVRTabController::setAllowAsyncReprojection(bool value, bool notify) { if (m_allowAsyncReprojection != value) { m_allowAsyncReprojection = value; - vr::VRSettings()->SetBool(vr::k_pch_SteamVR_Section, vrsettings_steamvr_allowAsyncReprojection, m_allowAsyncReprojection); + vr::VRSettings()->SetBool(vr::k_pch_SteamVR_Section, vr::k_pch_SteamVR_AllowAsyncReprojection_Bool, m_allowAsyncReprojection); vr::VRSettings()->Sync(); if (notify) { emit allowAsyncReprojectionChanged(m_allowAsyncReprojection); @@ -178,14 +178,14 @@ void SteamVRTabController::reset() { LOG(WARNING) << "Could not remove \"" << vrsettings_compositor_category << "::" << vr::k_pch_SteamVR_RenderTargetMultiplier_Float << "\" setting: " << vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError); } - vr::VRSettings()->RemoveKeyInSection(vr::k_pch_SteamVR_Section, vrsettings_steamvr_allowInterleavedReprojection, &vrSettingsError); + vr::VRSettings()->RemoveKeyInSection(vr::k_pch_SteamVR_Section, vr::k_pch_SteamVR_AllowReprojection_Bool, &vrSettingsError); if (vrSettingsError != vr::VRSettingsError_None) { - LOG(WARNING) << "Could not remove \"" << vrsettings_steamvr_allowInterleavedReprojection << "\" setting: " << vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError); + LOG(WARNING) << "Could not remove \"" << vr::k_pch_SteamVR_AllowReprojection_Bool << "\" setting: " << vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError); } - vr::VRSettings()->RemoveKeyInSection(vr::k_pch_SteamVR_Section, vrsettings_steamvr_allowAsyncReprojection, &vrSettingsError); + vr::VRSettings()->RemoveKeyInSection(vr::k_pch_SteamVR_Section, vr::k_pch_SteamVR_AllowAsyncReprojection_Bool, &vrSettingsError); if (vrSettingsError != vr::VRSettingsError_None) { - LOG(WARNING) << "Could not remove \"" << vrsettings_steamvr_allowAsyncReprojection << "\" setting: " << vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError); + LOG(WARNING) << "Could not remove \"" << vr::k_pch_SteamVR_AllowAsyncReprojection_Bool << "\" setting: " << vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError); } vr::VRSettings()->RemoveKeyInSection(vr::k_pch_SteamVR_Section, vr::k_pch_SteamVR_ForceReprojection_Bool, &vrSettingsError); diff --git a/src/tabcontrollers/SteamVRTabController.h b/src/tabcontrollers/SteamVRTabController.h index 55a4a5f..e9aab8d 100644 --- a/src/tabcontrollers/SteamVRTabController.h +++ b/src/tabcontrollers/SteamVRTabController.h @@ -4,8 +4,8 @@ #include // openvr's github repo hasn't been updated yet to reflect changes in beta 1477423729. -static const char* vrsettings_steamvr_allowAsyncReprojection = "allowAsyncReprojection"; -static const char* vrsettings_steamvr_allowInterleavedReprojection = "allowInterleavedReprojection"; +//static const char* vrsettings_steamvr_allowAsyncReprojection = "allowAsyncReprojection"; +//static const char* vrsettings_steamvr_allowInterleavedReprojection = "allowInterleavedReprojection"; static const char* vrsettings_compositor_category = "compositor"; diff --git a/src/tabcontrollers/UtilitiesTabController.cpp b/src/tabcontrollers/UtilitiesTabController.cpp index 3a40706..566d696 100644 --- a/src/tabcontrollers/UtilitiesTabController.cpp +++ b/src/tabcontrollers/UtilitiesTabController.cpp @@ -2,12 +2,21 @@ #include #include "../overlaycontroller.h" #include +#include // application namespace namespace advsettings { void UtilitiesTabController::initStage1() { + auto settings = OverlayController::appSettings(); + settings->beginGroup("utilitiesSettings"); + auto qAlarmEnabled = settings->value("alarmEnabled", m_alarmEnabled); + auto qAlarmHour = settings->value("alarmHour", 0); + auto qAlarmMinute = settings->value("alarmMinute", 0); + settings->endGroup(); + m_alarmEnabled = qAlarmEnabled.toBool(); + m_alarmTime = QTime(qAlarmHour.toInt(), qAlarmMinute.toInt()); } void UtilitiesTabController::initStage2(OverlayController * parent, QQuickWindow * widget) { @@ -146,4 +155,171 @@ namespace advsettings { } } + + bool UtilitiesTabController::alarmEnabled() const { + return m_alarmEnabled; + } + + int UtilitiesTabController::alarmTimeHour() const { + return m_alarmTime.hour(); + } + + int UtilitiesTabController::alarmTimeMinute() const { + return m_alarmTime.minute(); + } + + void UtilitiesTabController::setAlarmEnabled(bool enabled, bool notify) { + if (m_alarmEnabled != enabled) { + m_alarmEnabled = enabled; + auto settings = OverlayController::appSettings(); + settings->beginGroup("utilitiesSettings"); + settings->setValue("alarmEnabled", m_alarmEnabled); + settings->endGroup(); + settings->sync(); + m_alarmLastCheckTime = QTime(); + if (notify) { + emit alarmEnabledChanged(m_alarmEnabled); + } + } + } + + void UtilitiesTabController::setAlarmTimeHour(int hour, bool notify) { + if (m_alarmTime.hour() != hour) { + if (m_alarmTime.isValid()) { + m_alarmTime = QTime(hour, m_alarmTime.minute()); + } else { + m_alarmTime = QTime(hour, 0); + } + auto settings = OverlayController::appSettings(); + settings->beginGroup("utilitiesSettings"); + settings->setValue("alarmHour", m_alarmTime.hour()); + settings->setValue("alarmMinute", m_alarmTime.minute()); + settings->endGroup(); + settings->sync(); + m_alarmLastCheckTime = QTime(); + if (notify) { + emit alarmTimeHourChanged(hour); + } + } + } + + void UtilitiesTabController::setAlarmTimeMinute(int min, bool notify) { + if (m_alarmTime.minute() != min) { + if (m_alarmTime.isValid()) { + m_alarmTime = QTime(m_alarmTime.hour(), min); + } else { + m_alarmTime = QTime(0, min); + } + auto settings = OverlayController::appSettings(); + settings->beginGroup("utilitiesSettings"); + settings->setValue("alarmHour", m_alarmTime.hour()); + settings->setValue("alarmMinute", m_alarmTime.minute()); + settings->endGroup(); + settings->sync(); + m_alarmLastCheckTime = QTime(); + if (notify) { + emit alarmTimeMinuteChanged(min); + } + } + } + + void UtilitiesTabController::setAlarmTimeToCurrentTime() { + auto now = QTime::currentTime(); + setAlarmTimeHour(now.hour()); + setAlarmTimeMinute(now.minute()); + } + + void UtilitiesTabController::modAlarmTimeHour(int value, bool notify) { + auto h = m_alarmTime.hour(); + m_alarmTime = m_alarmTime.addSecs(value * 60 * 60); + auto settings = OverlayController::appSettings(); + settings->beginGroup("utilitiesSettings"); + settings->setValue("alarmHour", m_alarmTime.hour()); + settings->setValue("alarmMinute", m_alarmTime.minute()); + settings->endGroup(); + settings->sync(); + if (h != m_alarmTime.hour()) { + m_alarmLastCheckTime = QTime(); + if (notify) { + emit alarmTimeHourChanged(m_alarmTime.hour()); + } + } + } + + void UtilitiesTabController::modAlarmTimeMinute(int value, bool notify) { + auto h = m_alarmTime.hour(); + auto m = m_alarmTime.minute(); + m_alarmTime = m_alarmTime.addSecs(value * 60); + auto settings = OverlayController::appSettings(); + settings->beginGroup("utilitiesSettings"); + settings->setValue("alarmHour", m_alarmTime.hour()); + settings->setValue("alarmMinute", m_alarmTime.minute()); + settings->endGroup(); + settings->sync(); + if (m != m_alarmTime.minute() || h != m_alarmTime.hour()) { + m_alarmLastCheckTime = QTime(); + if (notify) { + if (h != m_alarmTime.hour()) { + emit alarmTimeHourChanged(m_alarmTime.hour()); + } + if (m != m_alarmTime.minute()) { + emit alarmTimeMinuteChanged(m_alarmTime.minute()); + } + } + } + } + + + void UtilitiesTabController::eventLoopTick() { + if (settingsUpdateCounter >= 10) { + if (m_alarmEnabled && m_alarmTime.isValid()) { + auto now = QTime::currentTime(); + if (m_alarmLastCheckTime.isValid() && m_alarmLastCheckTime <= m_alarmTime && m_alarmTime <= now) { + setAlarmEnabled(false); + char alarmMessageBuffer[1024]; + std::snprintf(alarmMessageBuffer, 1024, "The alarm at %02i:%02i went off.", alarmTimeHour(), alarmTimeMinute()); + vr::VRNotificationId notificationId; + vr::EVRInitError eError; + vr::IVRNotifications* vrnotification = (vr::IVRNotifications*)vr::VR_GetGenericInterface(vr::IVRNotifications_Version, &eError); + if (eError != vr::VRInitError_None) { + LOG(ERROR) << "Error while getting IVRNotifications interface" << vr::VR_GetVRInitErrorAsEnglishDescription(eError); + vrnotification = nullptr; + } else { + auto nError = vrnotification->CreateNotification( + parent->overlayThumbnailHandle(), 666, vr::EVRNotificationType_Transient_SystemWithUserValue, alarmMessageBuffer, vr::EVRNotificationStyle_Application, nullptr, ¬ificationId + ); + if (nError != vr::VRNotificationError_OK) { + LOG(ERROR) << "Error while creating notification: " << nError; + vrnotification = nullptr; + } + } + if (!vr::VROverlay()->IsDashboardVisible()) { // message overlay is not shown when the dashboard is visible (see https://github.com/ValveSoftware/openvr/issues/348) + std::thread messageThread([](UtilitiesTabController* parent, std::string message) { + auto res = vr::VROverlay()->ShowMessageOverlay(message.c_str(), "Alarm Clock", "Ok", "+15 min"); + if (res == vr::VRMessageOverlayResponse_ButtonPress_1) { + parent->setAlarmTimeToCurrentTime(); + parent->modAlarmTimeMinute(15); + parent->setAlarmEnabled(true); + } else if (res >= vr::VRMessageOverlayResponse_CouldntFindSystemOverlay) { + static const char* errorMessages[] = { "CouldntFindSystemOverlay", "CouldntFindOrCreateClientOverlay", "ApplicationQuit" }; + int errorCode = res - vr::VRMessageOverlayResponse_CouldntFindSystemOverlay; + if (res < 3) { + LOG(ERROR) << "Could not create Alarm Overlay: " << errorMessages[errorCode]; + } else { + LOG(ERROR) << "Could not create Alarm Overlay: Unknown Error"; + } + } + }, this, std::string(alarmMessageBuffer)); + messageThread.detach(); + } + } + m_alarmLastCheckTime = now; + } + settingsUpdateCounter = 0; + } else { + settingsUpdateCounter++; + } + } + + } // namespace advconfig diff --git a/src/tabcontrollers/UtilitiesTabController.h b/src/tabcontrollers/UtilitiesTabController.h index fb83aba..4213e57 100644 --- a/src/tabcontrollers/UtilitiesTabController.h +++ b/src/tabcontrollers/UtilitiesTabController.h @@ -2,6 +2,7 @@ #pragma once #include +#include class QQuickWindow; // application namespace @@ -13,21 +14,46 @@ namespace advsettings { class UtilitiesTabController : public QObject { Q_OBJECT + Q_PROPERTY(bool alarmEnabled READ alarmEnabled WRITE setAlarmEnabled NOTIFY alarmEnabledChanged) + Q_PROPERTY(int alarmTimeHour READ alarmTimeHour WRITE setAlarmTimeHour NOTIFY alarmTimeHourChanged) + Q_PROPERTY(int alarmTimeMinute READ alarmTimeMinute WRITE setAlarmTimeMinute NOTIFY alarmTimeMinuteChanged) private: OverlayController* parent; QQuickWindow* widget; + unsigned settingsUpdateCounter = 0; + + bool m_alarmEnabled = false; + QTime m_alarmTime; + QTime m_alarmLastCheckTime; + public: void initStage1(); void initStage2(OverlayController* parent, QQuickWindow* widget); + void eventLoopTick(); + + bool alarmEnabled() const; + int alarmTimeHour() const; + int alarmTimeMinute() const; + public slots: void sendKeyboardInput(QString input); void sendKeyboardEnter(); void sendKeyboardBackspace(int count); + void setAlarmEnabled(bool enabled, bool notify = true); + void setAlarmTimeHour(int hour, bool notify = true); + void setAlarmTimeMinute(int min, bool notify = true); + void setAlarmTimeToCurrentTime(); + void modAlarmTimeHour(int value, bool notify = true); + void modAlarmTimeMinute(int value, bool notify = true); + signals: + void alarmEnabledChanged(bool enabled); + void alarmTimeHourChanged(int hour); + void alarmTimeMinuteChanged(int min); }; } // namespace advsettings diff --git a/third-party/openvr/bin/linux64/libopenvr_api.so b/third-party/openvr/bin/linux64/libopenvr_api.so index 692a87c..7b6f2d2 100644 Binary files a/third-party/openvr/bin/linux64/libopenvr_api.so and b/third-party/openvr/bin/linux64/libopenvr_api.so differ diff --git a/third-party/openvr/bin/linux64/libopenvr_api.so.dbg b/third-party/openvr/bin/linux64/libopenvr_api.so.dbg index 6285a38..c100646 100644 Binary files a/third-party/openvr/bin/linux64/libopenvr_api.so.dbg and b/third-party/openvr/bin/linux64/libopenvr_api.so.dbg differ diff --git a/third-party/openvr/bin/osx32/libopenvr_api.dylib b/third-party/openvr/bin/osx32/libopenvr_api.dylib index e3e871a..647ec3f 100644 Binary files a/third-party/openvr/bin/osx32/libopenvr_api.dylib and b/third-party/openvr/bin/osx32/libopenvr_api.dylib differ diff --git a/third-party/openvr/bin/osx32/libopenvr_api.dylib.dSYM/Contents/Resources/DWARF/libopenvr_api.dylib b/third-party/openvr/bin/osx32/libopenvr_api.dylib.dSYM/Contents/Resources/DWARF/libopenvr_api.dylib index 9b6372f..67ae4da 100644 Binary files a/third-party/openvr/bin/osx32/libopenvr_api.dylib.dSYM/Contents/Resources/DWARF/libopenvr_api.dylib and b/third-party/openvr/bin/osx32/libopenvr_api.dylib.dSYM/Contents/Resources/DWARF/libopenvr_api.dylib differ diff --git a/third-party/openvr/bin/win32/openvr_api.dll b/third-party/openvr/bin/win32/openvr_api.dll index 2dd3fbe..7aa2b99 100644 Binary files a/third-party/openvr/bin/win32/openvr_api.dll and b/third-party/openvr/bin/win32/openvr_api.dll differ diff --git a/third-party/openvr/bin/win32/openvr_api.pdb b/third-party/openvr/bin/win32/openvr_api.pdb index 5a43d1b..a5d24ae 100644 Binary files a/third-party/openvr/bin/win32/openvr_api.pdb and b/third-party/openvr/bin/win32/openvr_api.pdb differ diff --git a/third-party/openvr/bin/win64/openvr_api.dll b/third-party/openvr/bin/win64/openvr_api.dll index 9ae4922..bbcccde 100644 Binary files a/third-party/openvr/bin/win64/openvr_api.dll and b/third-party/openvr/bin/win64/openvr_api.dll differ diff --git a/third-party/openvr/bin/win64/openvr_api.pdb b/third-party/openvr/bin/win64/openvr_api.pdb index e575e13..b2e1f15 100644 Binary files a/third-party/openvr/bin/win64/openvr_api.pdb and b/third-party/openvr/bin/win64/openvr_api.pdb differ diff --git a/third-party/openvr/include/openvr.h b/third-party/openvr/include/openvr.h index b72fcae..6617b4d 100644 --- a/third-party/openvr/include/openvr.h +++ b/third-party/openvr/include/openvr.h @@ -111,10 +111,11 @@ enum EVREye Eye_Right = 1 }; -enum EGraphicsAPIConvention +enum ETextureType { - API_DirectX = 0, // Normalized Z goes from 0 at the viewer to 1 at the far clip plane - API_OpenGL = 1, // Normalized Z goes from 1 at the viewer to -1 at the far clip plane + TextureType_DirectX = 0, // Handle is an ID3D11Texture + TextureType_OpenGL = 1, // Handle is an OpenGL texture name or an OpenGL render buffer name, depending on submit flags + TextureType_Vulkan = 2, // Handle is a pointer to a VRVulkanTextureData_t structure }; enum EColorSpace @@ -126,8 +127,8 @@ enum EColorSpace struct Texture_t { - void* handle; // Native d3d texture pointer or GL texture id. - EGraphicsAPIConvention eType; + void* handle; // See ETextureType definition above + ETextureType eType; EColorSpace eColorSpace; }; @@ -146,7 +147,6 @@ enum ETrackingResult TrackingResult_Running_OutOfRange = 201, }; -static const uint32_t k_unTrackingStringSize = 32; static const uint32_t k_unMaxDriverDebugResponseSize = 32768; /** Used to pass device IDs to API calls */ @@ -162,11 +162,8 @@ enum ETrackedDeviceClass TrackedDeviceClass_Invalid = 0, // the ID was not valid. TrackedDeviceClass_HMD = 1, // Head-Mounted Displays TrackedDeviceClass_Controller = 2, // Tracked controllers + TrackedDeviceClass_GenericTracker = 3, // Generic trackers, similar to controllers TrackedDeviceClass_TrackingReference = 4, // Camera and base stations that serve as tracking reference points - - TrackedDeviceClass_Count, // This isn't a class that will ever be returned. It is used for allocating arrays and such - - TrackedDeviceClass_Other = 1000, }; @@ -199,7 +196,7 @@ enum ETrackingUniverseOrigin { TrackingUniverseSeated = 0, // Poses are provided relative to the seated zero pose TrackingUniverseStanding = 1, // Poses are provided relative to the safe bounds configured by the user - TrackingUniverseRawAndUncalibrated = 2, // Poses are provided in the coordinate system defined by the driver. You probably don't want this one. + TrackingUniverseRawAndUncalibrated = 2, // Poses are provided in the coordinate system defined by the driver. It has Y up and is unified for devices of the same driver. You usually don't want this one. }; @@ -207,6 +204,8 @@ enum ETrackingUniverseOrigin * tracked device. Many fields are only valid for one ETrackedDeviceClass. */ enum ETrackedDeviceProperty { + Prop_Invalid = 0, + // general properties that apply to all device classes Prop_TrackingSystemName_String = 1000, Prop_ModelNumber_String = 1001, @@ -241,6 +240,7 @@ enum ETrackedDeviceProperty Prop_HasCamera_Bool = 1030, Prop_DriverVersion_String = 1031, Prop_Firmware_ForceUpdateRequired_Bool = 1032, + Prop_ViveSystemButtonFixRequired_Bool = 1033, // Properties that are unique to TrackedDeviceClass_HMD Prop_ReportsTimeSinceVSync_Bool = 2000, @@ -280,6 +280,7 @@ enum ETrackedDeviceProperty Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034, Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035, Prop_DisplaySuppressed_Bool = 2036, + Prop_DisplayAllowNightMode_Bool = 2037, // Properties that are unique to TrackedDeviceClass_Controller Prop_AttachedDeviceId_String = 3000, @@ -332,6 +333,7 @@ enum ETrackedPropertyError TrackedProp_ValueNotProvidedByDevice = 7, TrackedProp_StringExceedsMaximumLength = 8, TrackedProp_NotYetAvailable = 9, // The property value isn't known yet, but is expected soon. Call again later. + TrackedProp_PermissionDenied = 10, }; /** Allows the application to control what part of the provided texture will be used in the @@ -357,13 +359,13 @@ enum EVRSubmitFlags // If the texture pointer passed in is actually a renderbuffer (e.g. for MSAA in OpenGL) then set this flag. Submit_GlRenderBuffer = 0x02, - // Handle is pointer to VulkanData_t - Submit_VulkanTexture = 0x04, + // Do not use + Submit_Reserved = 0x04, }; /** Data required for passing Vulkan textures to IVRCompositor::Submit. * Be sure to call OpenVR_Shutdown before destroying these resources. */ -struct VulkanData_t +struct VRVulkanTextureData_t { uint64_t m_nImage; // VkImage VkDevice_T *m_pDevice; @@ -516,6 +518,8 @@ enum EVREventType VREvent_PerformanceTest_EnableCapture = 1600, VREvent_PerformanceTest_DisableCapture = 1601, VREvent_PerformanceTest_FidelityLevel = 1602, + + VREvent_MessageOverlay_Closed = 1650, // Vendors are free to expose private events in this reserved region VREvent_VendorSpecific_Reserved_Start = 10000, @@ -702,7 +706,12 @@ struct VREvent_EditingCameraSurface_t uint32_t nVisualMode; }; -/** If you change this you must manually update openvr_interop.cs.py */ +struct VREvent_MessageOverlay_t +{ + uint32_t unVRMessageOverlayResponse; // vr::VRMessageOverlayResponse enum +}; + +/** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py */ typedef union { VREvent_Reserved_t reserved; @@ -723,6 +732,7 @@ typedef union VREvent_ScreenshotProgress_t screenshotProgress; VREvent_ApplicationLaunch_t applicationLaunch; VREvent_EditingCameraSurface_t cameraSurface; + VREvent_MessageOverlay_t messageOverlay; } VREvent_Data_t; /** An event posted by the server to all running applications */ @@ -749,6 +759,14 @@ struct HiddenAreaMesh_t }; +enum EHiddenAreaMeshType +{ + k_eHiddenAreaMesh_Standard = 0, + k_eHiddenAreaMesh_Inverse = 1, + k_eHiddenAreaMesh_LineLoop = 2, +}; + + /** Identifies what kind of axis is on the controller at index n. Read this type * with pVRSystem->Get( nControllerDeviceIndex, Prop_Axis0Type_Int32 + n ); */ @@ -832,26 +850,28 @@ static const VROverlayHandle_t k_ulOverlayHandleInvalid = 0; /** Errors that can occur around VR overlays */ enum EVROverlayError { - VROverlayError_None = 0, + VROverlayError_None = 0, - VROverlayError_UnknownOverlay = 10, - VROverlayError_InvalidHandle = 11, - VROverlayError_PermissionDenied = 12, - VROverlayError_OverlayLimitExceeded = 13, // No more overlays could be created because the maximum number already exist - VROverlayError_WrongVisibilityType = 14, - VROverlayError_KeyTooLong = 15, - VROverlayError_NameTooLong = 16, - VROverlayError_KeyInUse = 17, - VROverlayError_WrongTransformType = 18, - VROverlayError_InvalidTrackedDevice = 19, - VROverlayError_InvalidParameter = 20, - VROverlayError_ThumbnailCantBeDestroyed = 21, - VROverlayError_ArrayTooSmall = 22, - VROverlayError_RequestFailed = 23, - VROverlayError_InvalidTexture = 24, - VROverlayError_UnableToLoadFile = 25, - VROverlayError_KeyboardAlreadyInUse = 26, - VROverlayError_NoNeighbor = 27, + VROverlayError_UnknownOverlay = 10, + VROverlayError_InvalidHandle = 11, + VROverlayError_PermissionDenied = 12, + VROverlayError_OverlayLimitExceeded = 13, // No more overlays could be created because the maximum number already exist + VROverlayError_WrongVisibilityType = 14, + VROverlayError_KeyTooLong = 15, + VROverlayError_NameTooLong = 16, + VROverlayError_KeyInUse = 17, + VROverlayError_WrongTransformType = 18, + VROverlayError_InvalidTrackedDevice = 19, + VROverlayError_InvalidParameter = 20, + VROverlayError_ThumbnailCantBeDestroyed = 21, + VROverlayError_ArrayTooSmall = 22, + VROverlayError_RequestFailed = 23, + VROverlayError_InvalidTexture = 24, + VROverlayError_UnableToLoadFile = 25, + VROverlayError_KeyboardAlreadyInUse = 26, + VROverlayError_NoNeighbor = 27, + VROverlayError_TooManyMaskPrimitives = 29, + VROverlayError_BadMaskPrimitive = 30, }; /** enum values to pass in to VR_Init to identify whether the application will @@ -933,6 +953,8 @@ enum EVRInitError VRInitError_Init_InvalidApplicationType = 130, VRInitError_Init_NotAvailableToWatchdogApps = 131, VRInitError_Init_WatchdogDisabledInSettings = 132, + VRInitError_Init_VRDashboardNotFound = 133, + VRInitError_Init_VRDashboardStartupFailed = 134, VRInitError_Driver_Failed = 200, VRInitError_Driver_Unknown = 201, @@ -1120,16 +1142,16 @@ public: virtual void GetRecommendedRenderTargetSize( uint32_t *pnWidth, uint32_t *pnHeight ) = 0; /** The projection matrix for the specified eye */ - virtual HmdMatrix44_t GetProjectionMatrix( EVREye eEye, float fNearZ, float fFarZ, EGraphicsAPIConvention eProjType ) = 0; + virtual HmdMatrix44_t GetProjectionMatrix( EVREye eEye, float fNearZ, float fFarZ ) = 0; /** The components necessary to build your own projection matrix in case your * application is doing something fancy like infinite Z */ virtual void GetProjectionRaw( EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom ) = 0; - /** Returns the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in + /** Gets the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in * the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport. - * Values may be NAN to indicate an error has occurred. */ - virtual DistortionCoordinates_t ComputeDistortion( EVREye eEye, float fU, float fV ) = 0; + * Returns true for success. Otherwise, returns false, and distortion coordinates are not suitable. */ + virtual bool ComputeDistortion( EVREye eEye, float fU, float fV, DistortionCoordinates_t *pDistortionCoordinates ) = 0; /** Returns the transform from eye space to the head space. Eye space is the per-eye flavor of head * space that provides stereo disparity. Instead of Model * View * Projection the sequence is Model * View * Eye^-1 * Projection. @@ -1265,7 +1287,7 @@ public: /** Returns a string property. If the device index is not valid or the property is not a string type this function will * return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing - * null. Strings will generally fit in buffers of k_unTrackingStringSize characters. */ + * null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */ virtual uint32_t GetStringTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L ) = 0; /** returns a string that corresponds with the specified property error. The string will be the name @@ -1293,14 +1315,15 @@ public: // Rendering helper methods // ------------------------------------ - /** Returns the stencil mesh information for the current HMD. If this HMD does not have a stencil mesh the vertex data and count will be - * NULL and 0 respectively. This mesh is meant to be rendered into the stencil buffer (or into the depth buffer setting nearz) before rendering - * each eye's view. The pixels covered by this mesh will never be seen by the user after the lens distortion is applied and based on visibility to the panels. - * This will improve perf by letting the GPU early-reject pixels the user will never see before running the pixel shader. + /** Returns the hidden area mesh for the current HMD. The pixels covered by this mesh will never be seen by the user after the lens distortion is + * applied based on visibility to the panels. If this HMD does not have a hidden area mesh, the vertex data and count will be NULL and 0 respectively. + * This mesh is meant to be rendered into the stencil buffer (or into the depth buffer setting nearz) before rendering each eye's view. + * This will improve performance by letting the GPU early-reject pixels the user will never see before running the pixel shader. * NOTE: Render this mesh with backface culling disabled since the winding order of the vertices can be different per-HMD or per-eye. + * Setting the bInverse argument to true will produce the visible area mesh that is commonly used in place of full-screen quads. The visible area mesh covers all of the pixels the hidden area mesh does not cover. + * Setting the bLineLoop argument will return a line loop of vertices in HiddenAreaMesh_t->pVertexData with HiddenAreaMesh_t->unTriangleCount set to the number of vertices. */ - virtual HiddenAreaMesh_t GetHiddenAreaMesh( EVREye eEye ) = 0; - + virtual HiddenAreaMesh_t GetHiddenAreaMesh( EVREye eEye, EHiddenAreaMeshType type = k_eHiddenAreaMesh_Standard ) = 0; // ------------------------------------ // Controller methods @@ -1308,12 +1331,12 @@ public: /** Fills the supplied struct with the current state of the controller. Returns false if the controller index * is invalid. */ - virtual bool GetControllerState( vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState ) = 0; + virtual bool GetControllerState( vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize ) = 0; /** fills the supplied struct with the current state of the controller and the provided pose with the pose of * the controller when the controller state was updated most recently. Use this form if you need a precise controller * pose as input to your application when the user presses or releases a button. */ - virtual bool GetControllerStateWithPose( ETrackingUniverseOrigin eOrigin, vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, TrackedDevicePose_t *pTrackedDevicePose ) = 0; + virtual bool GetControllerStateWithPose( ETrackingUniverseOrigin eOrigin, vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose ) = 0; /** Trigger a single haptic pulse on a controller. After this call the application may not trigger another haptic pulse on this controller * and axis combination for 5ms. */ @@ -1346,7 +1369,6 @@ public: * The size of the response including its terminating null is returned. */ virtual uint32_t DriverDebugRequest( vr::TrackedDeviceIndex_t unDeviceIndex, const char *pchRequest, char *pchResponseBuffer, uint32_t unResponseBufferSize ) = 0; - // ------------------------------------ // Firmware methods // ------------------------------------ @@ -1358,7 +1380,6 @@ public: * Prop_Firmware_ManualUpdateURL_String should point to an URL describing the manual update process */ virtual vr::EVRFirmwareError PerformFirmwareUpdate( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0; - // ------------------------------------ // Application life cycle methods // ------------------------------------ @@ -1374,7 +1395,7 @@ public: }; -static const char * const IVRSystem_Version = "IVRSystem_012"; +static const char * const IVRSystem_Version = "IVRSystem_015"; } @@ -1630,7 +1651,6 @@ namespace vr //----------------------------------------------------------------------------- // steamvr keys - static const char * const k_pch_SteamVR_Section = "steamvr"; static const char * const k_pch_SteamVR_RequireHmd_String = "requireHmd"; static const char * const k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver"; @@ -1644,9 +1664,9 @@ namespace vr static const char * const k_pch_SteamVR_LogLevel_Int32 = "loglevel"; static const char * const k_pch_SteamVR_IPD_Float = "ipd"; static const char * const k_pch_SteamVR_Background_String = "background"; + static const char * const k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection"; static const char * const k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight"; static const char * const k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius"; - static const char * const k_pch_SteamVR_Environment_String = "environment"; static const char * const k_pch_SteamVR_GridColor_String = "gridColor"; static const char * const k_pch_SteamVR_PlayAreaColor_String = "playAreaColor"; static const char * const k_pch_SteamVR_ShowStage_Bool = "showStage"; @@ -1659,33 +1679,34 @@ namespace vr static const char * const k_pch_SteamVR_BaseStationPowerManagement_Bool = "basestationPowerManagement"; static const char * const k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses"; static const char * const k_pch_SteamVR_RenderTargetMultiplier_Float = "renderTargetMultiplier"; - static const char * const k_pch_SteamVR_AllowReprojection_Bool = "allowReprojection"; + static const char * const k_pch_SteamVR_AllowAsyncReprojection_Bool = "allowAsyncReprojection"; + static const char * const k_pch_SteamVR_AllowReprojection_Bool = "allowInterleavedReprojection"; static const char * const k_pch_SteamVR_ForceReprojection_Bool = "forceReprojection"; static const char * const k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking"; static const char * const k_pch_SteamVR_DefaultMirrorView_Int32 = "defaultMirrorView"; static const char * const k_pch_SteamVR_ShowMirrorView_Bool = "showMirrorView"; static const char * const k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry"; static const char * const k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch"; + static const char * const k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch"; + static const char * const k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch"; + static const char * const k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard"; static const char * const k_pch_SteamVR_EnableHomeApp = "enableHomeApp"; static const char * const k_pch_SteamVR_SetInitialDefaultHomeApp = "setInitialDefaultHomeApp"; static const char * const k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec"; static const char * const k_pch_SteamVR_RetailDemo_Bool = "retailDemo"; - + static const char * const k_pch_SteamVR_IpdOffset_Float = "ipdOffset"; //----------------------------------------------------------------------------- // lighthouse keys - static const char * const k_pch_Lighthouse_Section = "driver_lighthouse"; static const char * const k_pch_Lighthouse_DisableIMU_Bool = "disableimu"; static const char * const k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation"; static const char * const k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug"; - static const char * const k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation"; static const char * const k_pch_Lighthouse_DBHistory_Bool = "dbhistory"; //----------------------------------------------------------------------------- // null keys - static const char * const k_pch_Null_Section = "driver_null"; static const char * const k_pch_Null_EnableNullDriver_Bool = "enable"; static const char * const k_pch_Null_SerialNumber_String = "serialNumber"; @@ -1703,6 +1724,7 @@ namespace vr // user interface keys static const char * const k_pch_UserInterface_Section = "userinterface"; static const char * const k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop"; + static const char * const k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray"; static const char * const k_pch_UserInterface_Screenshots_Bool = "screenshots"; static const char * const k_pch_UserInterface_ScreenshotType_Int = "screenshotType"; @@ -1817,7 +1839,7 @@ enum ChaperoneCalibrationState // Errors ChaperoneCalibrationState_Error = 200, // The UniverseID is invalid - ChaperoneCalibrationState_Error_BaseStationUninitalized = 201, // Tracking center hasn't be calibrated for at least one of the base stations + ChaperoneCalibrationState_Error_BaseStationUninitialized = 201, // Tracking center hasn't be calibrated for at least one of the base stations ChaperoneCalibrationState_Error_BaseStationConflict = 202, // Tracking center is calibrated, but base stations disagree on the tracking space ChaperoneCalibrationState_Error_PlayAreaInvalid = 203, // Play Area hasn't been calibrated for the current tracking center ChaperoneCalibrationState_Error_CollisionBoundsInvalid = 204, // Collision Bounds haven't been calibrated for the current tracking center @@ -1987,10 +2009,17 @@ enum EVRCompositorError VRCompositorError_TextureUsesUnsupportedFormat = 105, VRCompositorError_SharedTexturesNotSupported = 106, VRCompositorError_IndexOutOfRange = 107, + VRCompositorError_AlreadySubmitted = 108, }; const uint32_t VRCompositor_ReprojectionReason_Cpu = 0x01; const uint32_t VRCompositor_ReprojectionReason_Gpu = 0x02; +const uint32_t VRCompositor_ReprojectionAsync = 0x04; // This flag indicates the async reprojection mode is active, + // but does not indicate if reprojection actually happened or not. + // Use the ReprojectionReason flags above to check if reprojection + // was actually applied (i.e. scene texture was reused). + // NumFramePresents > 1 also indicates the scene texture was reused, + // and also the number of times that it was presented in total. /** Provides a single frame's timing information to the app */ struct Compositor_FrameTiming @@ -1998,6 +2027,7 @@ struct Compositor_FrameTiming uint32_t m_nSize; // Set to sizeof( Compositor_FrameTiming ) uint32_t m_nFrameIndex; uint32_t m_nNumFramePresents; // number of times this frame was presented + uint32_t m_nNumMisPresented; // number of times this frame was presented on a vsync other than it was originally predicted to uint32_t m_nNumDroppedFrames; // number of additional times previous frame was scanned out uint32_t m_nReprojectionFlags; @@ -2074,7 +2104,14 @@ public: /** Gets current tracking space returned by WaitGetPoses */ virtual ETrackingUniverseOrigin GetTrackingSpace() = 0; - /** Returns pose(s) to use to render scene (and optionally poses predicted two frames out for gameplay). */ + /** Scene applications should call this function to get poses to render with (and optionally poses predicted an additional frame out to use for gameplay). + * This function will block until "running start" milliseconds before the start of the frame, and should be called at the last moment before needing to + * start rendering. + * + * Return codes: + * - IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene) + * - DoNotHaveFocus (some other app has taken focus - this will throttle the call to 10hz to reduce the impact on that app) + */ virtual EVRCompositorError WaitGetPoses( VR_ARRAY_COUNT(unRenderPoseArrayCount) TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount, VR_ARRAY_COUNT(unGamePoseArrayCount) TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount ) = 0; @@ -2092,6 +2129,15 @@ public: * * OpenGL dirty state: * glBindTexture + * + * Return codes: + * - IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene) + * - DoNotHaveFocus (some other app has taken focus) + * - TextureIsOnWrongDevice (application did not use proper AdapterIndex - see IVRSystem.GetDXGIOutputInfo) + * - SharedTexturesNotSupported (application needs to call CreateDXGIFactory1 or later before creating DX device) + * - TextureUsesUnsupportedFormat (scene textures must be compatible with DXGI sharing rules - e.g. uncompressed, no mips, etc.) + * - InvalidTexture (usually means bad arguments passed in) + * - AlreadySubmitted (app has submitted two left textures or two right textures in a single frame - i.e. before calling WaitGetPoses again) */ virtual EVRCompositorError Submit( EVREye eEye, const Texture_t *pTexture, const VRTextureBounds_t* pBounds = 0, EVRSubmitFlags nSubmitFlags = Submit_Default ) = 0; @@ -2110,6 +2156,10 @@ public: * Be sure to set timing.size = sizeof(Compositor_FrameTiming) on struct passed in before calling this function. */ virtual bool GetFrameTiming( Compositor_FrameTiming *pTiming, uint32_t unFramesAgo = 0 ) = 0; + /** Interface for copying a range of timing data. Frames are returned in ascending order (oldest to newest) with the last being the most recent frame. + * Only the first entry's m_nSize needs to be set, as the rest will be inferred from that. Returns total number of entries filled out. */ + virtual uint32_t GetFrameTimings( Compositor_FrameTiming *pTiming, uint32_t nFrames ) = 0; + /** Returns the time in seconds left in the current (as identified by FrameTiming's frameIndex) frame. * Due to "running start", this value may roll over to the next frame before ever reaching 0.0. */ virtual float GetFrameTimeRemaining() = 0; @@ -2122,9 +2172,15 @@ public: * would be FadeToColor( 0.0, 0.0, 0.0, 0.0, 0.0 ). Values are in un-premultiplied alpha space. */ virtual void FadeToColor( float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground = false ) = 0; + /** Get current fade color value. */ + virtual HmdColor_t GetCurrentFadeColor( bool bBackground = false ) = 0; + /** Fading the Grid in or out in fSeconds */ virtual void FadeGrid( float fSeconds, bool bFadeIn ) = 0; + /** Get current alpha value of grid. */ + virtual float GetCurrentGridAlpha() = 0; + /** Override the skybox used in the compositor (e.g. for during level loads when the app can't feed scene images fast enough) * Order is Front, Back, Left, Right, Top, Bottom. If only a single texture is passed, it is assumed in lat-long format. * If two are passed, it is assumed a lat-long stereo pair. */ @@ -2189,9 +2245,20 @@ public: virtual bool ReleaseSharedGLTexture( vr::glUInt_t glTextureId, vr::glSharedTextureHandle_t glSharedTextureHandle ) = 0; virtual void LockGLSharedTextureForAccess( vr::glSharedTextureHandle_t glSharedTextureHandle ) = 0; virtual void UnlockGLSharedTextureForAccess( vr::glSharedTextureHandle_t glSharedTextureHandle ) = 0; + + /** [Vulkan Only] + * return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing + * null. The string will be a space separated list of-required instance extensions to enable in VkCreateInstance */ + virtual uint32_t GetVulkanInstanceExtensionsRequired( VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) = 0; + + /** [Vulkan only] + * return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing + * null. The string will be a space separated list of required device extensions to enable in VkCreateDevice */ + virtual uint32_t GetVulkanDeviceExtensionsRequired( VkPhysicalDevice_T *pPhysicalDevice, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) = 0; + }; -static const char * const IVRCompositor_Version = "IVRCompositor_016"; +static const char * const IVRCompositor_Version = "IVRCompositor_019"; } // namespace vr @@ -2308,6 +2375,9 @@ namespace vr /** The maximum number of overlays that can exist in the system at one time. */ static const uint32_t k_unMaxOverlayCount = 64; + /** The maximum number of overlay intersection mask primitives per overlay */ + static const uint32_t k_unMaxOverlayIntersectionMaskPrimitivesCount = 32; + /** Types of input supported by VR Overlays */ enum VROverlayInputMethod { @@ -2364,6 +2434,20 @@ namespace vr // If this is set on an overlay owned by the scene application that overlay // will be sorted with the "Other" overlays on top of all other scene overlays VROverlayFlags_SortWithNonSceneOverlays = 14, + + // If set, the overlay will be shown in the dashboard, otherwise it will be hidden. + VROverlayFlags_VisibleInDashboard = 15, + }; + + enum VRMessageOverlayResponse + { + VRMessageOverlayResponse_ButtonPress_0 = 0, + VRMessageOverlayResponse_ButtonPress_1 = 1, + VRMessageOverlayResponse_ButtonPress_2 = 2, + VRMessageOverlayResponse_ButtonPress_3 = 3, + VRMessageOverlayResponse_CouldntFindSystemOverlay = 4, + VRMessageOverlayResponse_CouldntFindOrCreateClientOverlay= 5, + VRMessageOverlayResponse_ApplicationQuit = 6 }; struct VROverlayIntersectionParams_t @@ -2407,6 +2491,40 @@ namespace vr OverlayDirection_Count = 4, }; + enum EVROverlayIntersectionMaskPrimitiveType + { + OverlayIntersectionPrimitiveType_Rectangle, + OverlayIntersectionPrimitiveType_Circle, + }; + + struct IntersectionMaskRectangle_t + { + float m_flTopLeftX; + float m_flTopLeftY; + float m_flWidth; + float m_flHeight; + }; + + struct IntersectionMaskCircle_t + { + float m_flCenterX; + float m_flCenterY; + float m_flRadius; + }; + + /** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py and openvr_api_flat.h.py */ + typedef union + { + IntersectionMaskRectangle_t m_Rectangle; + IntersectionMaskCircle_t m_Circle; + } VROverlayIntersectionMaskPrimitive_Data_t; + + struct VROverlayIntersectionMaskPrimitive_t + { + EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType; + VROverlayIntersectionMaskPrimitive_Data_t m_Primitive; + }; + class IVROverlay { public: @@ -2647,7 +2765,7 @@ namespace vr * pNativeTextureHandle is an OUTPUT, it will be a pointer to a ID3D11ShaderResourceView *. * pNativeTextureRef is an INPUT and should be a ID3D11Resource *. The device used by pNativeTextureRef will be used to bind pNativeTextureHandle. */ - virtual EVROverlayError GetOverlayTexture( VROverlayHandle_t ulOverlayHandle, void **pNativeTextureHandle, void *pNativeTextureRef, uint32_t *pWidth, uint32_t *pHeight, uint32_t *pNativeFormat, EGraphicsAPIConvention *pAPI, EColorSpace *pColorSpace ) = 0; + virtual EVROverlayError GetOverlayTexture( VROverlayHandle_t ulOverlayHandle, void **pNativeTextureHandle, void *pNativeTextureRef, uint32_t *pWidth, uint32_t *pHeight, uint32_t *pNativeFormat, ETextureType *pAPIType, EColorSpace *pColorSpace, VRTextureBounds_t *pTextureBounds ) = 0; /** Release the pNativeTextureHandle provided from the GetOverlayTexture call, this allows the system to free the underlying GPU resources for this object, * so only do it once you stop rendering this texture. @@ -2703,9 +2821,25 @@ namespace vr /** Set the position of the keyboard in overlay space by telling it to avoid a rectangle in the overlay. Rectangle coords have (0,0) in the bottom left **/ virtual void SetKeyboardPositionForOverlay( VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect ) = 0; + // --------------------------------------------- + // Overlay input methods + // --------------------------------------------- + + /** Sets a list of primitives to be used for controller ray intersection + * typically the size of the underlying UI in pixels (not in world space). */ + virtual EVROverlayError SetOverlayIntersectionMask( VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t *pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize = sizeof( VROverlayIntersectionMaskPrimitive_t ) ) = 0; + + virtual EVROverlayError GetOverlayFlags( VROverlayHandle_t ulOverlayHandle, uint32_t *pFlags ) = 0; + + // --------------------------------------------- + // Message box methods + // --------------------------------------------- + + /** Show the message overlay. This will block and return you a result. **/ + virtual VRMessageOverlayResponse ShowMessageOverlay( const char* pchText, const char* pchCaption, const char* pchButton0Text, const char* pchButton1Text = nullptr, const char* pchButton2Text = nullptr, const char* pchButton3Text = nullptr ) = 0; }; - static const char * const IVROverlay_Version = "IVROverlay_013"; + static const char * const IVROverlay_Version = "IVROverlay_014"; } // namespace vr @@ -2950,7 +3084,7 @@ public: /** Gets size of the image frame. */ virtual vr::EVRTrackedCameraError GetCameraFrameSize( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, uint32_t *pnWidth, uint32_t *pnHeight, uint32_t *pnFrameBufferSize ) = 0; - virtual vr::EVRTrackedCameraError GetCameraIntrinisics( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::HmdVector2_t *pFocalLength, vr::HmdVector2_t *pCenter ) = 0; + virtual vr::EVRTrackedCameraError GetCameraIntrinsics( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::HmdVector2_t *pFocalLength, vr::HmdVector2_t *pCenter ) = 0; virtual vr::EVRTrackedCameraError GetCameraProjection( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, vr::HmdMatrix44_t *pProjection ) = 0; @@ -2971,7 +3105,12 @@ public: /** Gets size of the image frame. */ virtual vr::EVRTrackedCameraError GetVideoStreamTextureSize( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::VRTextureBounds_t *pTextureBounds, uint32_t *pnWidth, uint32_t *pnHeight ) = 0; - /** Access a shared D3D11 texture for the specified tracked camera stream */ + /** Access a shared D3D11 texture for the specified tracked camera stream. + * The camera frame type VRTrackedCameraFrameType_Undistorted is not supported directly as a shared texture. It is an interior subregion of the shared texture VRTrackedCameraFrameType_MaximumUndistorted. + * Instead, use GetVideoStreamTextureSize() with VRTrackedCameraFrameType_Undistorted to determine the proper interior subregion bounds along with GetVideoStreamTextureD3D11() with + * VRTrackedCameraFrameType_MaximumUndistorted to provide the texture. The VRTrackedCameraFrameType_MaximumUndistorted will yield an image where the invalid regions are decoded + * by the alpha channel having a zero component. The valid regions all have a non-zero alpha component. The subregion as described by VRTrackedCameraFrameType_Undistorted + * guarantees a rectangle where all pixels are valid. */ virtual vr::EVRTrackedCameraError GetVideoStreamTextureD3D11( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize ) = 0; /** Access a shared GL texture for the specified tracked camera stream */ @@ -3172,7 +3311,6 @@ namespace vr // They will go away in the future. typedef EVRInitError HmdError; typedef EVREye Hmd_Eye; - typedef EGraphicsAPIConvention GraphicsAPIConvention; typedef EColorSpace ColorSpace; typedef ETrackingResult HmdTrackingResult; typedef ETrackedDeviceClass TrackedDeviceClass; diff --git a/third-party/openvr/include/openvr_api.cs b/third-party/openvr/include/openvr_api.cs index 8fcac88..98e09ef 100644 --- a/third-party/openvr/include/openvr_api.cs +++ b/third-party/openvr/include/openvr_api.cs @@ -21,7 +21,7 @@ public struct IVRSystem internal _GetRecommendedRenderTargetSize GetRecommendedRenderTargetSize; [UnmanagedFunctionPointer(CallingConvention.StdCall)] - internal delegate HmdMatrix44_t _GetProjectionMatrix(EVREye eEye, float fNearZ, float fFarZ, EGraphicsAPIConvention eProjType); + internal delegate HmdMatrix44_t _GetProjectionMatrix(EVREye eEye, float fNearZ, float fFarZ); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetProjectionMatrix GetProjectionMatrix; @@ -31,7 +31,7 @@ public struct IVRSystem internal _GetProjectionRaw GetProjectionRaw; [UnmanagedFunctionPointer(CallingConvention.StdCall)] - internal delegate DistortionCoordinates_t _ComputeDistortion(EVREye eEye, float fU, float fV); + internal delegate bool _ComputeDistortion(EVREye eEye, float fU, float fV, ref DistortionCoordinates_t pDistortionCoordinates); [MarshalAs(UnmanagedType.FunctionPtr)] internal _ComputeDistortion ComputeDistortion; @@ -171,17 +171,17 @@ public struct IVRSystem internal _GetEventTypeNameFromEnum GetEventTypeNameFromEnum; [UnmanagedFunctionPointer(CallingConvention.StdCall)] - internal delegate HiddenAreaMesh_t _GetHiddenAreaMesh(EVREye eEye); + internal delegate HiddenAreaMesh_t _GetHiddenAreaMesh(EVREye eEye, EHiddenAreaMeshType type); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetHiddenAreaMesh GetHiddenAreaMesh; [UnmanagedFunctionPointer(CallingConvention.StdCall)] - internal delegate bool _GetControllerState(uint unControllerDeviceIndex, ref VRControllerState_t pControllerState); + internal delegate bool _GetControllerState(uint unControllerDeviceIndex, ref VRControllerState_t pControllerState, uint unControllerStateSize); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetControllerState GetControllerState; [UnmanagedFunctionPointer(CallingConvention.StdCall)] - internal delegate bool _GetControllerStateWithPose(ETrackingUniverseOrigin eOrigin, uint unControllerDeviceIndex, ref VRControllerState_t pControllerState, ref TrackedDevicePose_t pTrackedDevicePose); + internal delegate bool _GetControllerStateWithPose(ETrackingUniverseOrigin eOrigin, uint unControllerDeviceIndex, ref VRControllerState_t pControllerState, uint unControllerStateSize, ref TrackedDevicePose_t pTrackedDevicePose); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetControllerStateWithPose GetControllerStateWithPose; @@ -276,9 +276,9 @@ public struct IVRTrackedCamera internal _GetCameraFrameSize GetCameraFrameSize; [UnmanagedFunctionPointer(CallingConvention.StdCall)] - internal delegate EVRTrackedCameraError _GetCameraIntrinisics(uint nDeviceIndex, EVRTrackedCameraFrameType eFrameType, ref HmdVector2_t pFocalLength, ref HmdVector2_t pCenter); + internal delegate EVRTrackedCameraError _GetCameraIntrinsics(uint nDeviceIndex, EVRTrackedCameraFrameType eFrameType, ref HmdVector2_t pFocalLength, ref HmdVector2_t pCenter); [MarshalAs(UnmanagedType.FunctionPtr)] - internal _GetCameraIntrinisics GetCameraIntrinisics; + internal _GetCameraIntrinsics GetCameraIntrinsics; [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EVRTrackedCameraError _GetCameraProjection(uint nDeviceIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, ref HmdMatrix44_t pProjection); @@ -675,6 +675,11 @@ public struct IVRCompositor [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetFrameTiming GetFrameTiming; + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetFrameTimings(ref Compositor_FrameTiming pTiming, uint nFrames); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetFrameTimings GetFrameTimings; + [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate float _GetFrameTimeRemaining(); [MarshalAs(UnmanagedType.FunctionPtr)] @@ -690,11 +695,21 @@ public struct IVRCompositor [MarshalAs(UnmanagedType.FunctionPtr)] internal _FadeToColor FadeToColor; + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HmdColor_t _GetCurrentFadeColor(bool bBackground); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCurrentFadeColor GetCurrentFadeColor; + [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate void _FadeGrid(float fSeconds, bool bFadeIn); [MarshalAs(UnmanagedType.FunctionPtr)] internal _FadeGrid FadeGrid; + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate float _GetCurrentGridAlpha(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCurrentGridAlpha GetCurrentGridAlpha; + [UnmanagedFunctionPointer(CallingConvention.StdCall)] internal delegate EVRCompositorError _SetSkyboxOverride([In, Out] Texture_t[] pTextures, uint unTextureCount); [MarshalAs(UnmanagedType.FunctionPtr)] @@ -805,6 +820,16 @@ public struct IVRCompositor [MarshalAs(UnmanagedType.FunctionPtr)] internal _UnlockGLSharedTextureForAccess UnlockGLSharedTextureForAccess; + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetVulkanInstanceExtensionsRequired(System.Text.StringBuilder pchValue, uint unBufferSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetVulkanInstanceExtensionsRequired GetVulkanInstanceExtensionsRequired; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetVulkanDeviceExtensionsRequired(IntPtr pPhysicalDevice, System.Text.StringBuilder pchValue, uint unBufferSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetVulkanDeviceExtensionsRequired GetVulkanDeviceExtensionsRequired; + } [StructLayout(LayoutKind.Sequential)] @@ -1091,7 +1116,7 @@ public struct IVROverlay internal _SetOverlayFromFile SetOverlayFromFile; [UnmanagedFunctionPointer(CallingConvention.StdCall)] - internal delegate EVROverlayError _GetOverlayTexture(ulong ulOverlayHandle, ref IntPtr pNativeTextureHandle, IntPtr pNativeTextureRef, ref uint pWidth, ref uint pHeight, ref uint pNativeFormat, ref EGraphicsAPIConvention pAPI, ref EColorSpace pColorSpace); + internal delegate EVROverlayError _GetOverlayTexture(ulong ulOverlayHandle, ref IntPtr pNativeTextureHandle, IntPtr pNativeTextureRef, ref uint pWidth, ref uint pHeight, ref uint pNativeFormat, ref ETextureType pAPIType, ref EColorSpace pColorSpace, ref VRTextureBounds_t pTextureBounds); [MarshalAs(UnmanagedType.FunctionPtr)] internal _GetOverlayTexture GetOverlayTexture; @@ -1170,6 +1195,21 @@ public struct IVROverlay [MarshalAs(UnmanagedType.FunctionPtr)] internal _SetKeyboardPositionForOverlay SetKeyboardPositionForOverlay; + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayIntersectionMask(ulong ulOverlayHandle, ref VROverlayIntersectionMaskPrimitive_t pMaskPrimitives, uint unNumMaskPrimitives, uint unPrimitiveSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayIntersectionMask SetOverlayIntersectionMask; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayFlags(ulong ulOverlayHandle, ref uint pFlags); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayFlags GetOverlayFlags; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate VRMessageOverlayResponse _ShowMessageOverlay(string pchText, string pchCaption, string pchButton0Text, string pchButton1Text, string pchButton2Text, string pchButton3Text); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowMessageOverlay ShowMessageOverlay; + } [StructLayout(LayoutKind.Sequential)] @@ -1416,9 +1456,9 @@ public class CVRSystem pnHeight = 0; FnTable.GetRecommendedRenderTargetSize(ref pnWidth,ref pnHeight); } - public HmdMatrix44_t GetProjectionMatrix(EVREye eEye,float fNearZ,float fFarZ,EGraphicsAPIConvention eProjType) + public HmdMatrix44_t GetProjectionMatrix(EVREye eEye,float fNearZ,float fFarZ) { - HmdMatrix44_t result = FnTable.GetProjectionMatrix(eEye,fNearZ,fFarZ,eProjType); + HmdMatrix44_t result = FnTable.GetProjectionMatrix(eEye,fNearZ,fFarZ); return result; } public void GetProjectionRaw(EVREye eEye,ref float pfLeft,ref float pfRight,ref float pfTop,ref float pfBottom) @@ -1429,9 +1469,9 @@ public class CVRSystem pfBottom = 0; FnTable.GetProjectionRaw(eEye,ref pfLeft,ref pfRight,ref pfTop,ref pfBottom); } - public DistortionCoordinates_t ComputeDistortion(EVREye eEye,float fU,float fV) + public bool ComputeDistortion(EVREye eEye,float fU,float fV,ref DistortionCoordinates_t pDistortionCoordinates) { - DistortionCoordinates_t result = FnTable.ComputeDistortion(eEye,fU,fV); + bool result = FnTable.ComputeDistortion(eEye,fU,fV,ref pDistortionCoordinates); return result; } public HmdMatrix34_t GetEyeToHeadTransform(EVREye eEye) @@ -1568,19 +1608,19 @@ public class CVRSystem IntPtr result = FnTable.GetEventTypeNameFromEnum(eType); return Marshal.PtrToStringAnsi(result); } - public HiddenAreaMesh_t GetHiddenAreaMesh(EVREye eEye) + public HiddenAreaMesh_t GetHiddenAreaMesh(EVREye eEye,EHiddenAreaMeshType type) { - HiddenAreaMesh_t result = FnTable.GetHiddenAreaMesh(eEye); + HiddenAreaMesh_t result = FnTable.GetHiddenAreaMesh(eEye,type); return result; } - public bool GetControllerState(uint unControllerDeviceIndex,ref VRControllerState_t pControllerState) + public bool GetControllerState(uint unControllerDeviceIndex,ref VRControllerState_t pControllerState,uint unControllerStateSize) { - bool result = FnTable.GetControllerState(unControllerDeviceIndex,ref pControllerState); + bool result = FnTable.GetControllerState(unControllerDeviceIndex,ref pControllerState,unControllerStateSize); return result; } - public bool GetControllerStateWithPose(ETrackingUniverseOrigin eOrigin,uint unControllerDeviceIndex,ref VRControllerState_t pControllerState,ref TrackedDevicePose_t pTrackedDevicePose) + public bool GetControllerStateWithPose(ETrackingUniverseOrigin eOrigin,uint unControllerDeviceIndex,ref VRControllerState_t pControllerState,uint unControllerStateSize,ref TrackedDevicePose_t pTrackedDevicePose) { - bool result = FnTable.GetControllerStateWithPose(eOrigin,unControllerDeviceIndex,ref pControllerState,ref pTrackedDevicePose); + bool result = FnTable.GetControllerStateWithPose(eOrigin,unControllerDeviceIndex,ref pControllerState,unControllerStateSize,ref pTrackedDevicePose); return result; } public void TriggerHapticPulse(uint unControllerDeviceIndex,uint unAxisId,char usDurationMicroSec) @@ -1690,9 +1730,9 @@ public class CVRTrackedCamera EVRTrackedCameraError result = FnTable.GetCameraFrameSize(nDeviceIndex,eFrameType,ref pnWidth,ref pnHeight,ref pnFrameBufferSize); return result; } - public EVRTrackedCameraError GetCameraIntrinisics(uint nDeviceIndex,EVRTrackedCameraFrameType eFrameType,ref HmdVector2_t pFocalLength,ref HmdVector2_t pCenter) + public EVRTrackedCameraError GetCameraIntrinsics(uint nDeviceIndex,EVRTrackedCameraFrameType eFrameType,ref HmdVector2_t pFocalLength,ref HmdVector2_t pCenter) { - EVRTrackedCameraError result = FnTable.GetCameraIntrinisics(nDeviceIndex,eFrameType,ref pFocalLength,ref pCenter); + EVRTrackedCameraError result = FnTable.GetCameraIntrinsics(nDeviceIndex,eFrameType,ref pFocalLength,ref pCenter); return result; } public EVRTrackedCameraError GetCameraProjection(uint nDeviceIndex,EVRTrackedCameraFrameType eFrameType,float flZNear,float flZFar,ref HmdMatrix44_t pProjection) @@ -2117,6 +2157,11 @@ public class CVRCompositor bool result = FnTable.GetFrameTiming(ref pTiming,unFramesAgo); return result; } + public uint GetFrameTimings(ref Compositor_FrameTiming pTiming,uint nFrames) + { + uint result = FnTable.GetFrameTimings(ref pTiming,nFrames); + return result; + } public float GetFrameTimeRemaining() { float result = FnTable.GetFrameTimeRemaining(); @@ -2130,10 +2175,20 @@ public class CVRCompositor { FnTable.FadeToColor(fSeconds,fRed,fGreen,fBlue,fAlpha,bBackground); } + public HmdColor_t GetCurrentFadeColor(bool bBackground) + { + HmdColor_t result = FnTable.GetCurrentFadeColor(bBackground); + return result; + } public void FadeGrid(float fSeconds,bool bFadeIn) { FnTable.FadeGrid(fSeconds,bFadeIn); } + public float GetCurrentGridAlpha() + { + float result = FnTable.GetCurrentGridAlpha(); + return result; + } public EVRCompositorError SetSkyboxOverride(Texture_t [] pTextures) { EVRCompositorError result = FnTable.SetSkyboxOverride(pTextures,(uint) pTextures.Length); @@ -2233,6 +2288,16 @@ public class CVRCompositor { FnTable.UnlockGLSharedTextureForAccess(glSharedTextureHandle); } + public uint GetVulkanInstanceExtensionsRequired(System.Text.StringBuilder pchValue,uint unBufferSize) + { + uint result = FnTable.GetVulkanInstanceExtensionsRequired(pchValue,unBufferSize); + return result; + } + public uint GetVulkanDeviceExtensionsRequired(IntPtr pPhysicalDevice,System.Text.StringBuilder pchValue,uint unBufferSize) + { + uint result = FnTable.GetVulkanDeviceExtensionsRequired(pPhysicalDevice,pchValue,unBufferSize); + return result; + } } @@ -2539,12 +2604,12 @@ public class CVROverlay EVROverlayError result = FnTable.SetOverlayFromFile(ulOverlayHandle,pchFilePath); return result; } - public EVROverlayError GetOverlayTexture(ulong ulOverlayHandle,ref IntPtr pNativeTextureHandle,IntPtr pNativeTextureRef,ref uint pWidth,ref uint pHeight,ref uint pNativeFormat,ref EGraphicsAPIConvention pAPI,ref EColorSpace pColorSpace) + public EVROverlayError GetOverlayTexture(ulong ulOverlayHandle,ref IntPtr pNativeTextureHandle,IntPtr pNativeTextureRef,ref uint pWidth,ref uint pHeight,ref uint pNativeFormat,ref ETextureType pAPIType,ref EColorSpace pColorSpace,ref VRTextureBounds_t pTextureBounds) { pWidth = 0; pHeight = 0; pNativeFormat = 0; - EVROverlayError result = FnTable.GetOverlayTexture(ulOverlayHandle,ref pNativeTextureHandle,pNativeTextureRef,ref pWidth,ref pHeight,ref pNativeFormat,ref pAPI,ref pColorSpace); + EVROverlayError result = FnTable.GetOverlayTexture(ulOverlayHandle,ref pNativeTextureHandle,pNativeTextureRef,ref pWidth,ref pHeight,ref pNativeFormat,ref pAPIType,ref pColorSpace,ref pTextureBounds); return result; } public EVROverlayError ReleaseNativeOverlayHandle(ulong ulOverlayHandle,IntPtr pNativeTextureHandle) @@ -2623,6 +2688,22 @@ public class CVROverlay { FnTable.SetKeyboardPositionForOverlay(ulOverlayHandle,avoidRect); } + public EVROverlayError SetOverlayIntersectionMask(ulong ulOverlayHandle,ref VROverlayIntersectionMaskPrimitive_t pMaskPrimitives,uint unNumMaskPrimitives,uint unPrimitiveSize) + { + EVROverlayError result = FnTable.SetOverlayIntersectionMask(ulOverlayHandle,ref pMaskPrimitives,unNumMaskPrimitives,unPrimitiveSize); + return result; + } + public EVROverlayError GetOverlayFlags(ulong ulOverlayHandle,ref uint pFlags) + { + pFlags = 0; + EVROverlayError result = FnTable.GetOverlayFlags(ulOverlayHandle,ref pFlags); + return result; + } + public VRMessageOverlayResponse ShowMessageOverlay(string pchText,string pchCaption,string pchButton0Text,string pchButton1Text,string pchButton2Text,string pchButton3Text) + { + VRMessageOverlayResponse result = FnTable.ShowMessageOverlay(pchText,pchCaption,pchButton0Text,pchButton1Text,pchButton2Text,pchButton3Text); + return result; + } } @@ -2876,21 +2957,21 @@ public class CVRResources public class OpenVRInterop { - [DllImportAttribute("openvr_api", EntryPoint = "VR_InitInternal")] + [DllImportAttribute("openvr_api", EntryPoint = "VR_InitInternal", CallingConvention = CallingConvention.Cdecl)] internal static extern uint InitInternal(ref EVRInitError peError, EVRApplicationType eApplicationType); - [DllImportAttribute("openvr_api", EntryPoint = "VR_ShutdownInternal")] + [DllImportAttribute("openvr_api", EntryPoint = "VR_ShutdownInternal", CallingConvention = CallingConvention.Cdecl)] internal static extern void ShutdownInternal(); - [DllImportAttribute("openvr_api", EntryPoint = "VR_IsHmdPresent")] + [DllImportAttribute("openvr_api", EntryPoint = "VR_IsHmdPresent", CallingConvention = CallingConvention.Cdecl)] internal static extern bool IsHmdPresent(); - [DllImportAttribute("openvr_api", EntryPoint = "VR_IsRuntimeInstalled")] + [DllImportAttribute("openvr_api", EntryPoint = "VR_IsRuntimeInstalled", CallingConvention = CallingConvention.Cdecl)] internal static extern bool IsRuntimeInstalled(); - [DllImportAttribute("openvr_api", EntryPoint = "VR_GetStringForHmdError")] + [DllImportAttribute("openvr_api", EntryPoint = "VR_GetStringForHmdError", CallingConvention = CallingConvention.Cdecl)] internal static extern IntPtr GetStringForHmdError(EVRInitError error); - [DllImportAttribute("openvr_api", EntryPoint = "VR_GetGenericInterface")] + [DllImportAttribute("openvr_api", EntryPoint = "VR_GetGenericInterface", CallingConvention = CallingConvention.Cdecl)] internal static extern IntPtr GetGenericInterface([In, MarshalAs(UnmanagedType.LPStr)] string pchInterfaceVersion, ref EVRInitError peError); - [DllImportAttribute("openvr_api", EntryPoint = "VR_IsInterfaceVersionValid")] + [DllImportAttribute("openvr_api", EntryPoint = "VR_IsInterfaceVersionValid", CallingConvention = CallingConvention.Cdecl)] internal static extern bool IsInterfaceVersionValid([In, MarshalAs(UnmanagedType.LPStr)] string pchInterfaceVersion); - [DllImportAttribute("openvr_api", EntryPoint = "VR_GetInitToken")] + [DllImportAttribute("openvr_api", EntryPoint = "VR_GetInitToken", CallingConvention = CallingConvention.Cdecl)] internal static extern uint GetInitToken(); } @@ -2900,10 +2981,11 @@ public enum EVREye Eye_Left = 0, Eye_Right = 1, } -public enum EGraphicsAPIConvention +public enum ETextureType { - API_DirectX = 0, - API_OpenGL = 1, + DirectX = 0, + OpenGL = 1, + Vulkan = 2, } public enum EColorSpace { @@ -2924,9 +3006,8 @@ public enum ETrackedDeviceClass Invalid = 0, HMD = 1, Controller = 2, + GenericTracker = 3, TrackingReference = 4, - Count = 5, - Other = 1000, } public enum ETrackedControllerRole { @@ -2942,6 +3023,7 @@ public enum ETrackingUniverseOrigin } public enum ETrackedDeviceProperty { + Prop_Invalid = 0, Prop_TrackingSystemName_String = 1000, Prop_ModelNumber_String = 1001, Prop_SerialNumber_String = 1002, @@ -2975,6 +3057,7 @@ public enum ETrackedDeviceProperty Prop_HasCamera_Bool = 1030, Prop_DriverVersion_String = 1031, Prop_Firmware_ForceUpdateRequired_Bool = 1032, + Prop_ViveSystemButtonFixRequired_Bool = 1033, Prop_ReportsTimeSinceVSync_Bool = 2000, Prop_SecondsFromVsyncToPhotons_Float = 2001, Prop_DisplayFrequency_Float = 2002, @@ -3012,6 +3095,7 @@ public enum ETrackedDeviceProperty Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034, Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035, Prop_DisplaySuppressed_Bool = 2036, + Prop_DisplayAllowNightMode_Bool = 2037, Prop_AttachedDeviceId_String = 3000, Prop_SupportedButtons_Uint64 = 3001, Prop_Axis0Type_Int32 = 3002, @@ -3051,13 +3135,14 @@ public enum ETrackedPropertyError TrackedProp_ValueNotProvidedByDevice = 7, TrackedProp_StringExceedsMaximumLength = 8, TrackedProp_NotYetAvailable = 9, + TrackedProp_PermissionDenied = 10, } public enum EVRSubmitFlags { Submit_Default = 0, Submit_LensDistortionAlreadyApplied = 1, Submit_GlRenderBuffer = 2, - Submit_VulkanTexture = 4, + Submit_Reserved = 4, } public enum EVRState { @@ -3176,6 +3261,7 @@ public enum EVREventType VREvent_PerformanceTest_EnableCapture = 1600, VREvent_PerformanceTest_DisableCapture = 1601, VREvent_PerformanceTest_FidelityLevel = 1602, + VREvent_MessageOverlay_Closed = 1650, VREvent_VendorSpecific_Reserved_Start = 10000, VREvent_VendorSpecific_Reserved_End = 19999, } @@ -3214,6 +3300,12 @@ public enum EVRMouseButton Right = 2, Middle = 4, } +public enum EHiddenAreaMeshType +{ + k_eHiddenAreaMesh_Standard = 0, + k_eHiddenAreaMesh_Inverse = 1, + k_eHiddenAreaMesh_LineLoop = 2, +} public enum EVRControllerAxisType { k_eControllerAxis_None = 0, @@ -3256,6 +3348,8 @@ public enum EVROverlayError UnableToLoadFile = 25, KeyboardAlreadyInUse = 26, NoNeighbor = 27, + TooManyMaskPrimitives = 29, + BadMaskPrimitive = 30, } public enum EVRApplicationType { @@ -3319,6 +3413,8 @@ public enum EVRInitError Init_InvalidApplicationType = 130, Init_NotAvailableToWatchdogApps = 131, Init_WatchdogDisabledInSettings = 132, + Init_VRDashboardNotFound = 133, + Init_VRDashboardStartupFailed = 134, Driver_Failed = 200, Driver_Unknown = 201, Driver_HmdUnknown = 202, @@ -3457,7 +3553,7 @@ public enum ChaperoneCalibrationState Warning_BaseStationRemoved = 102, Warning_SeatedBoundsInvalid = 103, Error = 200, - Error_BaseStationUninitalized = 201, + Error_BaseStationUninitialized = 201, Error_BaseStationConflict = 202, Error_PlayAreaInvalid = 203, Error_CollisionBoundsInvalid = 204, @@ -3483,6 +3579,7 @@ public enum EVRCompositorError TextureUsesUnsupportedFormat = 105, SharedTexturesNotSupported = 106, IndexOutOfRange = 107, + AlreadySubmitted = 108, } public enum VROverlayInputMethod { @@ -3513,6 +3610,17 @@ public enum VROverlayFlags Panorama = 12, StereoPanorama = 13, SortWithNonSceneOverlays = 14, + VisibleInDashboard = 15, +} +public enum VRMessageOverlayResponse +{ + ButtonPress_0 = 0, + ButtonPress_1 = 1, + ButtonPress_2 = 2, + ButtonPress_3 = 3, + CouldntFindSystemOverlay = 4, + CouldntFindOrCreateClientOverlay = 5, + ApplicationQuit = 6, } public enum EGamepadTextInputMode { @@ -3533,6 +3641,11 @@ public enum EOverlayDirection Right = 3, Count = 4, } +public enum EVROverlayIntersectionMaskPrimitiveType +{ + OverlayIntersectionPrimitiveType_Rectangle = 0, + OverlayIntersectionPrimitiveType_Circle = 1, +} public enum EVRRenderModelError { None = 0, @@ -3606,9 +3719,20 @@ public enum EVRScreenshotError [FieldOffset(0)] public VREvent_TouchPadMove_t touchPadMove; [FieldOffset(0)] public VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset; [FieldOffset(0)] public VREvent_Screenshot_t screenshot; + [FieldOffset(0)] public VREvent_ScreenshotProgress_t screenshotProgress; + [FieldOffset(0)] public VREvent_ApplicationLaunch_t applicationLaunch; + [FieldOffset(0)] public VREvent_EditingCameraSurface_t cameraSurface; + [FieldOffset(0)] public VREvent_MessageOverlay_t messageOverlay; [FieldOffset(0)] public VREvent_Keyboard_t keyboard; // This has to be at the end due to a mono bug } + +[StructLayout(LayoutKind.Explicit)] public struct VROverlayIntersectionMaskPrimitive_Data_t +{ + [FieldOffset(0)] public IntersectionMaskRectangle_t m_Rectangle; + [FieldOffset(0)] public IntersectionMaskCircle_t m_Circle; +} + [StructLayout(LayoutKind.Sequential)] public struct HmdMatrix34_t { public float m0; //float[3][4] @@ -3705,7 +3829,7 @@ public enum EVRScreenshotError [StructLayout(LayoutKind.Sequential)] public struct Texture_t { public IntPtr handle; // void * - public EGraphicsAPIConvention eType; + public ETextureType eType; public EColorSpace eColorSpace; } [StructLayout(LayoutKind.Sequential)] public struct TrackedDevicePose_t @@ -3726,7 +3850,7 @@ public enum EVRScreenshotError public float uMax; public float vMax; } -[StructLayout(LayoutKind.Sequential)] public struct VulkanData_t +[StructLayout(LayoutKind.Sequential)] public struct VRVulkanTextureData_t { public ulong m_nImage; public IntPtr m_pDevice; // struct VkDevice_T * @@ -3832,6 +3956,10 @@ public enum EVRScreenshotError public ulong overlayHandle; public uint nVisualMode; } +[StructLayout(LayoutKind.Sequential)] public struct VREvent_MessageOverlay_t +{ + public uint unVRMessageOverlayResponse; +} [StructLayout(LayoutKind.Sequential)] public struct VREvent_t { public uint eventType; @@ -3898,6 +4026,7 @@ public enum EVRScreenshotError public uint m_nSize; public uint m_nFrameIndex; public uint m_nNumFramePresents; + public uint m_nNumMisPresented; public uint m_nNumDroppedFrames; public uint m_nReprojectionFlags; public double m_flSystemTimeInSeconds; @@ -3950,6 +4079,24 @@ public enum EVRScreenshotError public HmdVector2_t vUVs; public float fDistance; } +[StructLayout(LayoutKind.Sequential)] public struct IntersectionMaskRectangle_t +{ + public float m_flTopLeftX; + public float m_flTopLeftY; + public float m_flWidth; + public float m_flHeight; +} +[StructLayout(LayoutKind.Sequential)] public struct IntersectionMaskCircle_t +{ + public float m_flCenterX; + public float m_flCenterY; + public float m_flRadius; +} +[StructLayout(LayoutKind.Sequential)] public struct VROverlayIntersectionMaskPrimitive_t +{ + public EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType; + public VROverlayIntersectionMaskPrimitive_Data_t m_Primitive; +} [StructLayout(LayoutKind.Sequential)] public struct RenderModel_ComponentState_t { public HmdMatrix34_t mTrackingToComponentRenderModel; @@ -4048,7 +4195,6 @@ public class OpenVR return OpenVRInterop.GetInitToken(); } - public const uint k_unTrackingStringSize = 32; public const uint k_unMaxDriverDebugResponseSize = 32768; public const uint k_unTrackedDeviceIndex_Hmd = 0; public const uint k_unMaxTrackedDeviceCount = 16; @@ -4058,7 +4204,7 @@ public class OpenVR public const uint k_unControllerStateAxisCount = 5; public const ulong k_ulOverlayHandleInvalid = 0; public const uint k_unScreenshotHandleInvalid = 0; - public const string IVRSystem_Version = "IVRSystem_012"; + public const string IVRSystem_Version = "IVRSystem_015"; public const string IVRExtendedDisplay_Version = "IVRExtendedDisplay_001"; public const string IVRTrackedCamera_Version = "IVRTrackedCamera_003"; public const uint k_unMaxApplicationKeyLength = 128; @@ -4067,11 +4213,12 @@ public class OpenVR public const string IVRApplications_Version = "IVRApplications_006"; public const string IVRChaperone_Version = "IVRChaperone_003"; public const string IVRChaperoneSetup_Version = "IVRChaperoneSetup_005"; - public const string IVRCompositor_Version = "IVRCompositor_016"; + public const string IVRCompositor_Version = "IVRCompositor_019"; public const uint k_unVROverlayMaxKeyLength = 128; public const uint k_unVROverlayMaxNameLength = 128; public const uint k_unMaxOverlayCount = 64; - public const string IVROverlay_Version = "IVROverlay_013"; + public const uint k_unMaxOverlayIntersectionMaskPrimitivesCount = 32; + public const string IVROverlay_Version = "IVROverlay_014"; public const string k_pch_Controller_Component_GDC2015 = "gdc2015"; public const string k_pch_Controller_Component_Base = "base"; public const string k_pch_Controller_Component_Tip = "tip"; @@ -4095,9 +4242,9 @@ public class OpenVR public const string k_pch_SteamVR_LogLevel_Int32 = "loglevel"; public const string k_pch_SteamVR_IPD_Float = "ipd"; public const string k_pch_SteamVR_Background_String = "background"; + public const string k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection"; public const string k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight"; public const string k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius"; - public const string k_pch_SteamVR_Environment_String = "environment"; public const string k_pch_SteamVR_GridColor_String = "gridColor"; public const string k_pch_SteamVR_PlayAreaColor_String = "playAreaColor"; public const string k_pch_SteamVR_ShowStage_Bool = "showStage"; @@ -4110,17 +4257,22 @@ public class OpenVR public const string k_pch_SteamVR_BaseStationPowerManagement_Bool = "basestationPowerManagement"; public const string k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses"; public const string k_pch_SteamVR_RenderTargetMultiplier_Float = "renderTargetMultiplier"; - public const string k_pch_SteamVR_AllowReprojection_Bool = "allowReprojection"; + public const string k_pch_SteamVR_AllowAsyncReprojection_Bool = "allowAsyncReprojection"; + public const string k_pch_SteamVR_AllowReprojection_Bool = "allowInterleavedReprojection"; public const string k_pch_SteamVR_ForceReprojection_Bool = "forceReprojection"; public const string k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking"; public const string k_pch_SteamVR_DefaultMirrorView_Int32 = "defaultMirrorView"; public const string k_pch_SteamVR_ShowMirrorView_Bool = "showMirrorView"; public const string k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry"; public const string k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch"; + public const string k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch"; + public const string k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch"; + public const string k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard"; public const string k_pch_SteamVR_EnableHomeApp = "enableHomeApp"; public const string k_pch_SteamVR_SetInitialDefaultHomeApp = "setInitialDefaultHomeApp"; public const string k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec"; public const string k_pch_SteamVR_RetailDemo_Bool = "retailDemo"; + public const string k_pch_SteamVR_IpdOffset_Float = "ipdOffset"; public const string k_pch_Lighthouse_Section = "driver_lighthouse"; public const string k_pch_Lighthouse_DisableIMU_Bool = "disableimu"; public const string k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation"; @@ -4141,6 +4293,7 @@ public class OpenVR public const string k_pch_Null_DisplayFrequency_Float = "displayFrequency"; public const string k_pch_UserInterface_Section = "userinterface"; public const string k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop"; + public const string k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray"; public const string k_pch_UserInterface_Screenshots_Bool = "screenshots"; public const string k_pch_UserInterface_ScreenshotType_Int = "screenshotType"; public const string k_pch_Notifications_Section = "notifications"; diff --git a/third-party/openvr/include/openvr_api.json b/third-party/openvr/include/openvr_api.json index 832e864..24509ee 100644 --- a/third-party/openvr/include/openvr_api.json +++ b/third-party/openvr/include/openvr_api.json @@ -8,12 +8,12 @@ ,{"typedef": "vr::VROverlayHandle_t","type": "uint64_t"} ,{"typedef": "vr::TrackedCameraHandle_t","type": "uint64_t"} ,{"typedef": "vr::ScreenshotHandle_t","type": "uint32_t"} +,{"typedef": "vr::VROverlayIntersectionMaskPrimitive_Data_t","type": "union VROverlayIntersectionMaskPrimitive_Data_t"} ,{"typedef": "vr::VRComponentProperties","type": "uint32_t"} ,{"typedef": "vr::TextureID_t","type": "int32_t"} ,{"typedef": "vr::VRNotificationId","type": "uint32_t"} ,{"typedef": "vr::HmdError","type": "enum vr::EVRInitError"} ,{"typedef": "vr::Hmd_Eye","type": "enum vr::EVREye"} -,{"typedef": "vr::GraphicsAPIConvention","type": "enum vr::EGraphicsAPIConvention"} ,{"typedef": "vr::ColorSpace","type": "enum vr::EColorSpace"} ,{"typedef": "vr::HmdTrackingResult","type": "enum vr::ETrackingResult"} ,{"typedef": "vr::TrackedDeviceClass","type": "enum vr::ETrackedDeviceClass"} @@ -33,9 +33,10 @@ {"name": "Eye_Left","value": "0"} ,{"name": "Eye_Right","value": "1"} ]} -, {"enumname": "vr::EGraphicsAPIConvention","values": [ - {"name": "API_DirectX","value": "0"} - ,{"name": "API_OpenGL","value": "1"} +, {"enumname": "vr::ETextureType","values": [ + {"name": "TextureType_DirectX","value": "0"} + ,{"name": "TextureType_OpenGL","value": "1"} + ,{"name": "TextureType_Vulkan","value": "2"} ]} , {"enumname": "vr::EColorSpace","values": [ {"name": "ColorSpace_Auto","value": "0"} @@ -53,9 +54,8 @@ {"name": "TrackedDeviceClass_Invalid","value": "0"} ,{"name": "TrackedDeviceClass_HMD","value": "1"} ,{"name": "TrackedDeviceClass_Controller","value": "2"} + ,{"name": "TrackedDeviceClass_GenericTracker","value": "3"} ,{"name": "TrackedDeviceClass_TrackingReference","value": "4"} - ,{"name": "TrackedDeviceClass_Count","value": "5"} - ,{"name": "TrackedDeviceClass_Other","value": "1000"} ]} , {"enumname": "vr::ETrackedControllerRole","values": [ {"name": "TrackedControllerRole_Invalid","value": "0"} @@ -68,7 +68,8 @@ ,{"name": "TrackingUniverseRawAndUncalibrated","value": "2"} ]} , {"enumname": "vr::ETrackedDeviceProperty","values": [ - {"name": "Prop_TrackingSystemName_String","value": "1000"} + {"name": "Prop_Invalid","value": "0"} + ,{"name": "Prop_TrackingSystemName_String","value": "1000"} ,{"name": "Prop_ModelNumber_String","value": "1001"} ,{"name": "Prop_SerialNumber_String","value": "1002"} ,{"name": "Prop_RenderModelName_String","value": "1003"} @@ -101,6 +102,7 @@ ,{"name": "Prop_HasCamera_Bool","value": "1030"} ,{"name": "Prop_DriverVersion_String","value": "1031"} ,{"name": "Prop_Firmware_ForceUpdateRequired_Bool","value": "1032"} + ,{"name": "Prop_ViveSystemButtonFixRequired_Bool","value": "1033"} ,{"name": "Prop_ReportsTimeSinceVSync_Bool","value": "2000"} ,{"name": "Prop_SecondsFromVsyncToPhotons_Float","value": "2001"} ,{"name": "Prop_DisplayFrequency_Float","value": "2002"} @@ -138,6 +140,7 @@ ,{"name": "Prop_ScreenshotHorizontalFieldOfViewDegrees_Float","value": "2034"} ,{"name": "Prop_ScreenshotVerticalFieldOfViewDegrees_Float","value": "2035"} ,{"name": "Prop_DisplaySuppressed_Bool","value": "2036"} + ,{"name": "Prop_DisplayAllowNightMode_Bool","value": "2037"} ,{"name": "Prop_AttachedDeviceId_String","value": "3000"} ,{"name": "Prop_SupportedButtons_Uint64","value": "3001"} ,{"name": "Prop_Axis0Type_Int32","value": "3002"} @@ -176,12 +179,13 @@ ,{"name": "TrackedProp_ValueNotProvidedByDevice","value": "7"} ,{"name": "TrackedProp_StringExceedsMaximumLength","value": "8"} ,{"name": "TrackedProp_NotYetAvailable","value": "9"} + ,{"name": "TrackedProp_PermissionDenied","value": "10"} ]} , {"enumname": "vr::EVRSubmitFlags","values": [ {"name": "Submit_Default","value": "0"} ,{"name": "Submit_LensDistortionAlreadyApplied","value": "1"} ,{"name": "Submit_GlRenderBuffer","value": "2"} - ,{"name": "Submit_VulkanTexture","value": "4"} + ,{"name": "Submit_Reserved","value": "4"} ]} , {"enumname": "vr::EVRState","values": [ {"name": "VRState_Undefined","value": "-1"} @@ -298,6 +302,7 @@ ,{"name": "VREvent_PerformanceTest_EnableCapture","value": "1600"} ,{"name": "VREvent_PerformanceTest_DisableCapture","value": "1601"} ,{"name": "VREvent_PerformanceTest_FidelityLevel","value": "1602"} + ,{"name": "VREvent_MessageOverlay_Closed","value": "1650"} ,{"name": "VREvent_VendorSpecific_Reserved_Start","value": "10000"} ,{"name": "VREvent_VendorSpecific_Reserved_End","value": "19999"} ]} @@ -333,6 +338,11 @@ ,{"name": "VRMouseButton_Right","value": "2"} ,{"name": "VRMouseButton_Middle","value": "4"} ]} +, {"enumname": "vr::EHiddenAreaMeshType","values": [ + {"name": "k_eHiddenAreaMesh_Standard","value": "0"} + ,{"name": "k_eHiddenAreaMesh_Inverse","value": "1"} + ,{"name": "k_eHiddenAreaMesh_LineLoop","value": "2"} +]} , {"enumname": "vr::EVRControllerAxisType","values": [ {"name": "k_eControllerAxis_None","value": "0"} ,{"name": "k_eControllerAxis_TrackPad","value": "1"} @@ -371,6 +381,8 @@ ,{"name": "VROverlayError_UnableToLoadFile","value": "25"} ,{"name": "VROverlayError_KeyboardAlreadyInUse","value": "26"} ,{"name": "VROverlayError_NoNeighbor","value": "27"} + ,{"name": "VROverlayError_TooManyMaskPrimitives","value": "29"} + ,{"name": "VROverlayError_BadMaskPrimitive","value": "30"} ]} , {"enumname": "vr::EVRApplicationType","values": [ {"name": "VRApplication_Other","value": "0"} @@ -430,6 +442,8 @@ ,{"name": "VRInitError_Init_InvalidApplicationType","value": "130"} ,{"name": "VRInitError_Init_NotAvailableToWatchdogApps","value": "131"} ,{"name": "VRInitError_Init_WatchdogDisabledInSettings","value": "132"} + ,{"name": "VRInitError_Init_VRDashboardNotFound","value": "133"} + ,{"name": "VRInitError_Init_VRDashboardStartupFailed","value": "134"} ,{"name": "VRInitError_Driver_Failed","value": "200"} ,{"name": "VRInitError_Driver_Unknown","value": "201"} ,{"name": "VRInitError_Driver_HmdUnknown","value": "202"} @@ -560,7 +574,7 @@ ,{"name": "ChaperoneCalibrationState_Warning_BaseStationRemoved","value": "102"} ,{"name": "ChaperoneCalibrationState_Warning_SeatedBoundsInvalid","value": "103"} ,{"name": "ChaperoneCalibrationState_Error","value": "200"} - ,{"name": "ChaperoneCalibrationState_Error_BaseStationUninitalized","value": "201"} + ,{"name": "ChaperoneCalibrationState_Error_BaseStationUninitialized","value": "201"} ,{"name": "ChaperoneCalibrationState_Error_BaseStationConflict","value": "202"} ,{"name": "ChaperoneCalibrationState_Error_PlayAreaInvalid","value": "203"} ,{"name": "ChaperoneCalibrationState_Error_CollisionBoundsInvalid","value": "204"} @@ -583,6 +597,7 @@ ,{"name": "VRCompositorError_TextureUsesUnsupportedFormat","value": "105"} ,{"name": "VRCompositorError_SharedTexturesNotSupported","value": "106"} ,{"name": "VRCompositorError_IndexOutOfRange","value": "107"} + ,{"name": "VRCompositorError_AlreadySubmitted","value": "108"} ]} , {"enumname": "vr::VROverlayInputMethod","values": [ {"name": "VROverlayInputMethod_None","value": "0"} @@ -610,6 +625,16 @@ ,{"name": "VROverlayFlags_Panorama","value": "12"} ,{"name": "VROverlayFlags_StereoPanorama","value": "13"} ,{"name": "VROverlayFlags_SortWithNonSceneOverlays","value": "14"} + ,{"name": "VROverlayFlags_VisibleInDashboard","value": "15"} +]} +, {"enumname": "vr::VRMessageOverlayResponse","values": [ + {"name": "VRMessageOverlayResponse_ButtonPress_0","value": "0"} + ,{"name": "VRMessageOverlayResponse_ButtonPress_1","value": "1"} + ,{"name": "VRMessageOverlayResponse_ButtonPress_2","value": "2"} + ,{"name": "VRMessageOverlayResponse_ButtonPress_3","value": "3"} + ,{"name": "VRMessageOverlayResponse_CouldntFindSystemOverlay","value": "4"} + ,{"name": "VRMessageOverlayResponse_CouldntFindOrCreateClientOverlay","value": "5"} + ,{"name": "VRMessageOverlayResponse_ApplicationQuit","value": "6"} ]} , {"enumname": "vr::EGamepadTextInputMode","values": [ {"name": "k_EGamepadTextInputModeNormal","value": "0"} @@ -627,6 +652,10 @@ ,{"name": "OverlayDirection_Right","value": "3"} ,{"name": "OverlayDirection_Count","value": "4"} ]} +, {"enumname": "vr::EVROverlayIntersectionMaskPrimitiveType","values": [ + {"name": "OverlayIntersectionPrimitiveType_Rectangle","value": "0"} + ,{"name": "OverlayIntersectionPrimitiveType_Circle","value": "1"} +]} , {"enumname": "vr::EVRRenderModelError","values": [ {"name": "VRRenderModelError_None","value": "0"} ,{"name": "VRRenderModelError_Loading","value": "100"} @@ -679,8 +708,6 @@ ]} ], "consts":[{ - "constname": "k_unTrackingStringSize","consttype": "const uint32_t", "constval": "32"} -,{ "constname": "k_unMaxDriverDebugResponseSize","consttype": "const uint32_t", "constval": "32768"} ,{ "constname": "k_unTrackedDeviceIndex_Hmd","consttype": "const uint32_t", "constval": "0"} @@ -699,7 +726,7 @@ ,{ "constname": "k_unScreenshotHandleInvalid","consttype": "const uint32_t", "constval": "0"} ,{ - "constname": "IVRSystem_Version","consttype": "const char *const", "constval": "IVRSystem_012"} + "constname": "IVRSystem_Version","consttype": "const char *const", "constval": "IVRSystem_015"} ,{ "constname": "IVRExtendedDisplay_Version","consttype": "const char *const", "constval": "IVRExtendedDisplay_001"} ,{ @@ -717,7 +744,7 @@ ,{ "constname": "IVRChaperoneSetup_Version","consttype": "const char *const", "constval": "IVRChaperoneSetup_005"} ,{ - "constname": "IVRCompositor_Version","consttype": "const char *const", "constval": "IVRCompositor_016"} + "constname": "IVRCompositor_Version","consttype": "const char *const", "constval": "IVRCompositor_019"} ,{ "constname": "k_unVROverlayMaxKeyLength","consttype": "const uint32_t", "constval": "128"} ,{ @@ -725,7 +752,9 @@ ,{ "constname": "k_unMaxOverlayCount","consttype": "const uint32_t", "constval": "64"} ,{ - "constname": "IVROverlay_Version","consttype": "const char *const", "constval": "IVROverlay_013"} + "constname": "k_unMaxOverlayIntersectionMaskPrimitivesCount","consttype": "const uint32_t", "constval": "32"} +,{ + "constname": "IVROverlay_Version","consttype": "const char *const", "constval": "IVROverlay_014"} ,{ "constname": "k_pch_Controller_Component_GDC2015","consttype": "const char *const", "constval": "gdc2015"} ,{ @@ -772,12 +801,12 @@ "constname": "k_pch_SteamVR_IPD_Float","consttype": "const char *const", "constval": "ipd"} ,{ "constname": "k_pch_SteamVR_Background_String","consttype": "const char *const", "constval": "background"} +,{ + "constname": "k_pch_SteamVR_BackgroundUseDomeProjection_Bool","consttype": "const char *const", "constval": "backgroundUseDomeProjection"} ,{ "constname": "k_pch_SteamVR_BackgroundCameraHeight_Float","consttype": "const char *const", "constval": "backgroundCameraHeight"} ,{ "constname": "k_pch_SteamVR_BackgroundDomeRadius_Float","consttype": "const char *const", "constval": "backgroundDomeRadius"} -,{ - "constname": "k_pch_SteamVR_Environment_String","consttype": "const char *const", "constval": "environment"} ,{ "constname": "k_pch_SteamVR_GridColor_String","consttype": "const char *const", "constval": "gridColor"} ,{ @@ -803,7 +832,9 @@ ,{ "constname": "k_pch_SteamVR_RenderTargetMultiplier_Float","consttype": "const char *const", "constval": "renderTargetMultiplier"} ,{ - "constname": "k_pch_SteamVR_AllowReprojection_Bool","consttype": "const char *const", "constval": "allowReprojection"} + "constname": "k_pch_SteamVR_AllowAsyncReprojection_Bool","consttype": "const char *const", "constval": "allowAsyncReprojection"} +,{ + "constname": "k_pch_SteamVR_AllowReprojection_Bool","consttype": "const char *const", "constval": "allowInterleavedReprojection"} ,{ "constname": "k_pch_SteamVR_ForceReprojection_Bool","consttype": "const char *const", "constval": "forceReprojection"} ,{ @@ -816,6 +847,12 @@ "constname": "k_pch_SteamVR_MirrorViewGeometry_String","consttype": "const char *const", "constval": "mirrorViewGeometry"} ,{ "constname": "k_pch_SteamVR_StartMonitorFromAppLaunch","consttype": "const char *const", "constval": "startMonitorFromAppLaunch"} +,{ + "constname": "k_pch_SteamVR_StartCompositorFromAppLaunch_Bool","consttype": "const char *const", "constval": "startCompositorFromAppLaunch"} +,{ + "constname": "k_pch_SteamVR_StartDashboardFromAppLaunch_Bool","consttype": "const char *const", "constval": "startDashboardFromAppLaunch"} +,{ + "constname": "k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool","consttype": "const char *const", "constval": "startOverlayAppsFromDashboard"} ,{ "constname": "k_pch_SteamVR_EnableHomeApp","consttype": "const char *const", "constval": "enableHomeApp"} ,{ @@ -824,6 +861,8 @@ "constname": "k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32","consttype": "const char *const", "constval": "CycleBackgroundImageTimeSec"} ,{ "constname": "k_pch_SteamVR_RetailDemo_Bool","consttype": "const char *const", "constval": "retailDemo"} +,{ + "constname": "k_pch_SteamVR_IpdOffset_Float","consttype": "const char *const", "constval": "ipdOffset"} ,{ "constname": "k_pch_Lighthouse_Section","consttype": "const char *const", "constval": "driver_lighthouse"} ,{ @@ -864,6 +903,8 @@ "constname": "k_pch_UserInterface_Section","consttype": "const char *const", "constval": "userinterface"} ,{ "constname": "k_pch_UserInterface_StatusAlwaysOnTop_Bool","consttype": "const char *const", "constval": "StatusAlwaysOnTop"} +,{ + "constname": "k_pch_UserInterface_MinimizeToTray_Bool","consttype": "const char *const", "constval": "MinimizeToTray"} ,{ "constname": "k_pch_UserInterface_Screenshots_Bool","consttype": "const char *const", "constval": "screenshots"} ,{ @@ -1014,7 +1055,7 @@ { "fieldname": "rfBlue", "fieldtype": "float [2]"}]} ,{"struct": "vr::Texture_t","fields": [ { "fieldname": "handle", "fieldtype": "void *"}, -{ "fieldname": "eType", "fieldtype": "enum vr::EGraphicsAPIConvention"}, +{ "fieldname": "eType", "fieldtype": "enum vr::ETextureType"}, { "fieldname": "eColorSpace", "fieldtype": "enum vr::EColorSpace"}]} ,{"struct": "vr::TrackedDevicePose_t","fields": [ { "fieldname": "mDeviceToAbsoluteTracking", "fieldtype": "struct vr::HmdMatrix34_t"}, @@ -1028,7 +1069,7 @@ { "fieldname": "vMin", "fieldtype": "float"}, { "fieldname": "uMax", "fieldtype": "float"}, { "fieldname": "vMax", "fieldtype": "float"}]} -,{"struct": "vr::VulkanData_t","fields": [ +,{"struct": "vr::VRVulkanTextureData_t","fields": [ { "fieldname": "m_nImage", "fieldtype": "uint64_t"}, { "fieldname": "m_pDevice", "fieldtype": "struct VkDevice_T *"}, { "fieldname": "m_pPhysicalDevice", "fieldtype": "struct VkPhysicalDevice_T *"}, @@ -1093,6 +1134,8 @@ ,{"struct": "vr::VREvent_EditingCameraSurface_t","fields": [ { "fieldname": "overlayHandle", "fieldtype": "uint64_t"}, { "fieldname": "nVisualMode", "fieldtype": "uint32_t"}]} +,{"struct": "vr::VREvent_MessageOverlay_t","fields": [ +{ "fieldname": "unVRMessageOverlayResponse", "fieldtype": "uint32_t"}]} ,{"struct": "vr::(anonymous)","fields": [ { "fieldname": "reserved", "fieldtype": "struct vr::VREvent_Reserved_t"}, { "fieldname": "controller", "fieldtype": "struct vr::VREvent_Controller_t"}, @@ -1111,7 +1154,8 @@ { "fieldname": "screenshot", "fieldtype": "struct vr::VREvent_Screenshot_t"}, { "fieldname": "screenshotProgress", "fieldtype": "struct vr::VREvent_ScreenshotProgress_t"}, { "fieldname": "applicationLaunch", "fieldtype": "struct vr::VREvent_ApplicationLaunch_t"}, -{ "fieldname": "cameraSurface", "fieldtype": "struct vr::VREvent_EditingCameraSurface_t"}]} +{ "fieldname": "cameraSurface", "fieldtype": "struct vr::VREvent_EditingCameraSurface_t"}, +{ "fieldname": "messageOverlay", "fieldtype": "struct vr::VREvent_MessageOverlay_t"}]} ,{"struct": "vr::VREvent_t","fields": [ { "fieldname": "eventType", "fieldtype": "uint32_t"}, { "fieldname": "trackedDeviceIndex", "fieldtype": "TrackedDeviceIndex_t"}, @@ -1157,6 +1201,7 @@ { "fieldname": "m_nSize", "fieldtype": "uint32_t"}, { "fieldname": "m_nFrameIndex", "fieldtype": "uint32_t"}, { "fieldname": "m_nNumFramePresents", "fieldtype": "uint32_t"}, +{ "fieldname": "m_nNumMisPresented", "fieldtype": "uint32_t"}, { "fieldname": "m_nNumDroppedFrames", "fieldtype": "uint32_t"}, { "fieldname": "m_nReprojectionFlags", "fieldtype": "uint32_t"}, { "fieldname": "m_flSystemTimeInSeconds", "fieldtype": "double"}, @@ -1202,6 +1247,21 @@ { "fieldname": "vNormal", "fieldtype": "struct vr::HmdVector3_t"}, { "fieldname": "vUVs", "fieldtype": "struct vr::HmdVector2_t"}, { "fieldname": "fDistance", "fieldtype": "float"}]} +,{"struct": "vr::IntersectionMaskRectangle_t","fields": [ +{ "fieldname": "m_flTopLeftX", "fieldtype": "float"}, +{ "fieldname": "m_flTopLeftY", "fieldtype": "float"}, +{ "fieldname": "m_flWidth", "fieldtype": "float"}, +{ "fieldname": "m_flHeight", "fieldtype": "float"}]} +,{"struct": "vr::IntersectionMaskCircle_t","fields": [ +{ "fieldname": "m_flCenterX", "fieldtype": "float"}, +{ "fieldname": "m_flCenterY", "fieldtype": "float"}, +{ "fieldname": "m_flRadius", "fieldtype": "float"}]} +,{"struct": "vr::(anonymous)","fields": [ +{ "fieldname": "m_Rectangle", "fieldtype": "struct vr::IntersectionMaskRectangle_t"}, +{ "fieldname": "m_Circle", "fieldtype": "struct vr::IntersectionMaskCircle_t"}]} +,{"struct": "vr::VROverlayIntersectionMaskPrimitive_t","fields": [ +{ "fieldname": "m_nPrimitiveType", "fieldtype": "enum vr::EVROverlayIntersectionMaskPrimitiveType"}, +{ "fieldname": "m_Primitive", "fieldtype": "VROverlayIntersectionMaskPrimitive_Data_t"}]} ,{"struct": "vr::RenderModel_ComponentState_t","fields": [ { "fieldname": "mTrackingToComponentRenderModel", "fieldtype": "struct vr::HmdMatrix34_t"}, { "fieldname": "mTrackingToComponentLocal", "fieldtype": "struct vr::HmdMatrix34_t"}, @@ -1257,8 +1317,7 @@ "params": [ { "paramname": "eEye" ,"paramtype": "vr::EVREye"}, { "paramname": "fNearZ" ,"paramtype": "float"}, -{ "paramname": "fFarZ" ,"paramtype": "float"}, -{ "paramname": "eProjType" ,"paramtype": "vr::EGraphicsAPIConvention"} +{ "paramname": "fFarZ" ,"paramtype": "float"} ] } ,{ @@ -1276,11 +1335,12 @@ ,{ "classname": "vr::IVRSystem", "methodname": "ComputeDistortion", - "returntype": "struct vr::DistortionCoordinates_t", + "returntype": "bool", "params": [ { "paramname": "eEye" ,"paramtype": "vr::EVREye"}, { "paramname": "fU" ,"paramtype": "float"}, -{ "paramname": "fV" ,"paramtype": "float"} +{ "paramname": "fV" ,"paramtype": "float"}, +{ "paramname": "pDistortionCoordinates" ,"paramtype": "struct vr::DistortionCoordinates_t *"} ] } ,{ @@ -1516,7 +1576,8 @@ "methodname": "GetHiddenAreaMesh", "returntype": "struct vr::HiddenAreaMesh_t", "params": [ -{ "paramname": "eEye" ,"paramtype": "vr::EVREye"} +{ "paramname": "eEye" ,"paramtype": "vr::EVREye"}, +{ "paramname": "type" ,"paramtype": "vr::EHiddenAreaMeshType"} ] } ,{ @@ -1525,7 +1586,8 @@ "returntype": "bool", "params": [ { "paramname": "unControllerDeviceIndex" ,"paramtype": "vr::TrackedDeviceIndex_t"}, -{ "paramname": "pControllerState" ,"paramtype": "vr::VRControllerState_t *"} +{ "paramname": "pControllerState" ,"paramtype": "vr::VRControllerState_t *"}, +{ "paramname": "unControllerStateSize" ,"paramtype": "uint32_t"} ] } ,{ @@ -1536,6 +1598,7 @@ { "paramname": "eOrigin" ,"paramtype": "vr::ETrackingUniverseOrigin"}, { "paramname": "unControllerDeviceIndex" ,"paramtype": "vr::TrackedDeviceIndex_t"}, { "paramname": "pControllerState" ,"paramtype": "vr::VRControllerState_t *"}, +{ "paramname": "unControllerStateSize" ,"paramtype": "uint32_t"}, { "paramname": "pTrackedDevicePose" ,"paramtype": "struct vr::TrackedDevicePose_t *"} ] } @@ -1672,7 +1735,7 @@ } ,{ "classname": "vr::IVRTrackedCamera", - "methodname": "GetCameraIntrinisics", + "methodname": "GetCameraIntrinsics", "returntype": "vr::EVRTrackedCameraError", "params": [ { "paramname": "nDeviceIndex" ,"paramtype": "vr::TrackedDeviceIndex_t"}, @@ -2333,6 +2396,15 @@ { "paramname": "unFramesAgo" ,"paramtype": "uint32_t"} ] } +,{ + "classname": "vr::IVRCompositor", + "methodname": "GetFrameTimings", + "returntype": "uint32_t", + "params": [ +{ "paramname": "pTiming" ,"paramtype": "struct vr::Compositor_FrameTiming *"}, +{ "paramname": "nFrames" ,"paramtype": "uint32_t"} + ] +} ,{ "classname": "vr::IVRCompositor", "methodname": "GetFrameTimeRemaining", @@ -2360,6 +2432,14 @@ { "paramname": "bBackground" ,"paramtype": "bool"} ] } +,{ + "classname": "vr::IVRCompositor", + "methodname": "GetCurrentFadeColor", + "returntype": "struct vr::HmdColor_t", + "params": [ +{ "paramname": "bBackground" ,"paramtype": "bool"} + ] +} ,{ "classname": "vr::IVRCompositor", "methodname": "FadeGrid", @@ -2369,6 +2449,11 @@ { "paramname": "bFadeIn" ,"paramtype": "bool"} ] } +,{ + "classname": "vr::IVRCompositor", + "methodname": "GetCurrentGridAlpha", + "returntype": "float" +} ,{ "classname": "vr::IVRCompositor", "methodname": "SetSkyboxOverride", @@ -2509,6 +2594,25 @@ { "paramname": "glSharedTextureHandle" ,"paramtype": "vr::glSharedTextureHandle_t"} ] } +,{ + "classname": "vr::IVRCompositor", + "methodname": "GetVulkanInstanceExtensionsRequired", + "returntype": "uint32_t", + "params": [ +{ "paramname": "pchValue" ,"out_string": " " ,"paramtype": "char *"}, +{ "paramname": "unBufferSize" ,"paramtype": "uint32_t"} + ] +} +,{ + "classname": "vr::IVRCompositor", + "methodname": "GetVulkanDeviceExtensionsRequired", + "returntype": "uint32_t", + "params": [ +{ "paramname": "pPhysicalDevice" ,"paramtype": "struct VkPhysicalDevice_T *"}, +{ "paramname": "pchValue" ,"out_string": " " ,"paramtype": "char *"}, +{ "paramname": "unBufferSize" ,"paramtype": "uint32_t"} + ] +} ,{ "classname": "vr::IVROverlay", "methodname": "FindOverlay", @@ -3037,8 +3141,9 @@ { "paramname": "pWidth" ,"paramtype": "uint32_t *"}, { "paramname": "pHeight" ,"paramtype": "uint32_t *"}, { "paramname": "pNativeFormat" ,"paramtype": "uint32_t *"}, -{ "paramname": "pAPI" ,"paramtype": "vr::EGraphicsAPIConvention *"}, -{ "paramname": "pColorSpace" ,"paramtype": "vr::EColorSpace *"} +{ "paramname": "pAPIType" ,"paramtype": "vr::ETextureType *"}, +{ "paramname": "pColorSpace" ,"paramtype": "vr::EColorSpace *"}, +{ "paramname": "pTextureBounds" ,"paramtype": "struct vr::VRTextureBounds_t *"} ] } ,{ @@ -3176,6 +3281,39 @@ { "paramname": "avoidRect" ,"paramtype": "struct vr::HmdRect2_t"} ] } +,{ + "classname": "vr::IVROverlay", + "methodname": "SetOverlayIntersectionMask", + "returntype": "vr::EVROverlayError", + "params": [ +{ "paramname": "ulOverlayHandle" ,"paramtype": "vr::VROverlayHandle_t"}, +{ "paramname": "pMaskPrimitives" ,"paramtype": "struct vr::VROverlayIntersectionMaskPrimitive_t *"}, +{ "paramname": "unNumMaskPrimitives" ,"paramtype": "uint32_t"}, +{ "paramname": "unPrimitiveSize" ,"paramtype": "uint32_t"} + ] +} +,{ + "classname": "vr::IVROverlay", + "methodname": "GetOverlayFlags", + "returntype": "vr::EVROverlayError", + "params": [ +{ "paramname": "ulOverlayHandle" ,"paramtype": "vr::VROverlayHandle_t"}, +{ "paramname": "pFlags" ,"paramtype": "uint32_t *"} + ] +} +,{ + "classname": "vr::IVROverlay", + "methodname": "ShowMessageOverlay", + "returntype": "vr::VRMessageOverlayResponse", + "params": [ +{ "paramname": "pchText" ,"paramtype": "const char *"}, +{ "paramname": "pchCaption" ,"paramtype": "const char *"}, +{ "paramname": "pchButton0Text" ,"paramtype": "const char *"}, +{ "paramname": "pchButton1Text" ,"paramtype": "const char *"}, +{ "paramname": "pchButton2Text" ,"paramtype": "const char *"}, +{ "paramname": "pchButton3Text" ,"paramtype": "const char *"} + ] +} ,{ "classname": "vr::IVRRenderModels", "methodname": "LoadRenderModel_Async", diff --git a/third-party/openvr/include/openvr_capi.h b/third-party/openvr/include/openvr_capi.h index fae48f8..daffdfb 100644 --- a/third-party/openvr/include/openvr_capi.h +++ b/third-party/openvr/include/openvr_capi.h @@ -46,12 +46,13 @@ #if defined( __WIN32 ) typedef char bool; +#else +#include #endif // OpenVR Constants -static const unsigned int k_unTrackingStringSize = 32; static const unsigned int k_unMaxDriverDebugResponseSize = 32768; static const unsigned int k_unTrackedDeviceIndex_Hmd = 0; static const unsigned int k_unMaxTrackedDeviceCount = 16; @@ -61,7 +62,7 @@ static const unsigned int k_unMaxPropertyStringSize = 32768; static const unsigned int k_unControllerStateAxisCount = 5; static const unsigned long k_ulOverlayHandleInvalid = 0; static const unsigned int k_unScreenshotHandleInvalid = 0; -static const char * IVRSystem_Version = "IVRSystem_012"; +static const char * IVRSystem_Version = "IVRSystem_015"; static const char * IVRExtendedDisplay_Version = "IVRExtendedDisplay_001"; static const char * IVRTrackedCamera_Version = "IVRTrackedCamera_003"; static const unsigned int k_unMaxApplicationKeyLength = 128; @@ -70,11 +71,12 @@ static const char * k_pch_MimeType_GameTheater = "vr/game_theater"; static const char * IVRApplications_Version = "IVRApplications_006"; static const char * IVRChaperone_Version = "IVRChaperone_003"; static const char * IVRChaperoneSetup_Version = "IVRChaperoneSetup_005"; -static const char * IVRCompositor_Version = "IVRCompositor_016"; +static const char * IVRCompositor_Version = "IVRCompositor_019"; static const unsigned int k_unVROverlayMaxKeyLength = 128; static const unsigned int k_unVROverlayMaxNameLength = 128; static const unsigned int k_unMaxOverlayCount = 64; -static const char * IVROverlay_Version = "IVROverlay_013"; +static const unsigned int k_unMaxOverlayIntersectionMaskPrimitivesCount = 32; +static const char * IVROverlay_Version = "IVROverlay_014"; static const char * k_pch_Controller_Component_GDC2015 = "gdc2015"; static const char * k_pch_Controller_Component_Base = "base"; static const char * k_pch_Controller_Component_Tip = "tip"; @@ -98,9 +100,9 @@ static const char * k_pch_SteamVR_SendSystemButtonToAllApps_Bool = "sendSystemBu static const char * k_pch_SteamVR_LogLevel_Int32 = "loglevel"; static const char * k_pch_SteamVR_IPD_Float = "ipd"; static const char * k_pch_SteamVR_Background_String = "background"; +static const char * k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection"; static const char * k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight"; static const char * k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius"; -static const char * k_pch_SteamVR_Environment_String = "environment"; static const char * k_pch_SteamVR_GridColor_String = "gridColor"; static const char * k_pch_SteamVR_PlayAreaColor_String = "playAreaColor"; static const char * k_pch_SteamVR_ShowStage_Bool = "showStage"; @@ -113,17 +115,22 @@ static const char * k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speak static const char * k_pch_SteamVR_BaseStationPowerManagement_Bool = "basestationPowerManagement"; static const char * k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses"; static const char * k_pch_SteamVR_RenderTargetMultiplier_Float = "renderTargetMultiplier"; -static const char * k_pch_SteamVR_AllowReprojection_Bool = "allowReprojection"; +static const char * k_pch_SteamVR_AllowAsyncReprojection_Bool = "allowAsyncReprojection"; +static const char * k_pch_SteamVR_AllowReprojection_Bool = "allowInterleavedReprojection"; static const char * k_pch_SteamVR_ForceReprojection_Bool = "forceReprojection"; static const char * k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking"; static const char * k_pch_SteamVR_DefaultMirrorView_Int32 = "defaultMirrorView"; static const char * k_pch_SteamVR_ShowMirrorView_Bool = "showMirrorView"; static const char * k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry"; static const char * k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch"; +static const char * k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch"; +static const char * k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch"; +static const char * k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard"; static const char * k_pch_SteamVR_EnableHomeApp = "enableHomeApp"; static const char * k_pch_SteamVR_SetInitialDefaultHomeApp = "setInitialDefaultHomeApp"; static const char * k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec"; static const char * k_pch_SteamVR_RetailDemo_Bool = "retailDemo"; +static const char * k_pch_SteamVR_IpdOffset_Float = "ipdOffset"; static const char * k_pch_Lighthouse_Section = "driver_lighthouse"; static const char * k_pch_Lighthouse_DisableIMU_Bool = "disableimu"; static const char * k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation"; @@ -144,6 +151,7 @@ static const char * k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsy static const char * k_pch_Null_DisplayFrequency_Float = "displayFrequency"; static const char * k_pch_UserInterface_Section = "userinterface"; static const char * k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop"; +static const char * k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray"; static const char * k_pch_UserInterface_Screenshots_Bool = "screenshots"; static const char * k_pch_UserInterface_ScreenshotType_Int = "screenshotType"; static const char * k_pch_Notifications_Section = "notifications"; @@ -211,11 +219,12 @@ typedef enum EVREye EVREye_Eye_Right = 1, } EVREye; -typedef enum EGraphicsAPIConvention +typedef enum ETextureType { - EGraphicsAPIConvention_API_DirectX = 0, - EGraphicsAPIConvention_API_OpenGL = 1, -} EGraphicsAPIConvention; + ETextureType_TextureType_DirectX = 0, + ETextureType_TextureType_OpenGL = 1, + ETextureType_TextureType_Vulkan = 2, +} ETextureType; typedef enum EColorSpace { @@ -238,9 +247,8 @@ typedef enum ETrackedDeviceClass ETrackedDeviceClass_TrackedDeviceClass_Invalid = 0, ETrackedDeviceClass_TrackedDeviceClass_HMD = 1, ETrackedDeviceClass_TrackedDeviceClass_Controller = 2, + ETrackedDeviceClass_TrackedDeviceClass_GenericTracker = 3, ETrackedDeviceClass_TrackedDeviceClass_TrackingReference = 4, - ETrackedDeviceClass_TrackedDeviceClass_Count = 5, - ETrackedDeviceClass_TrackedDeviceClass_Other = 1000, } ETrackedDeviceClass; typedef enum ETrackedControllerRole @@ -259,6 +267,7 @@ typedef enum ETrackingUniverseOrigin typedef enum ETrackedDeviceProperty { + ETrackedDeviceProperty_Prop_Invalid = 0, ETrackedDeviceProperty_Prop_TrackingSystemName_String = 1000, ETrackedDeviceProperty_Prop_ModelNumber_String = 1001, ETrackedDeviceProperty_Prop_SerialNumber_String = 1002, @@ -292,6 +301,7 @@ typedef enum ETrackedDeviceProperty ETrackedDeviceProperty_Prop_HasCamera_Bool = 1030, ETrackedDeviceProperty_Prop_DriverVersion_String = 1031, ETrackedDeviceProperty_Prop_Firmware_ForceUpdateRequired_Bool = 1032, + ETrackedDeviceProperty_Prop_ViveSystemButtonFixRequired_Bool = 1033, ETrackedDeviceProperty_Prop_ReportsTimeSinceVSync_Bool = 2000, ETrackedDeviceProperty_Prop_SecondsFromVsyncToPhotons_Float = 2001, ETrackedDeviceProperty_Prop_DisplayFrequency_Float = 2002, @@ -329,6 +339,7 @@ typedef enum ETrackedDeviceProperty ETrackedDeviceProperty_Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034, ETrackedDeviceProperty_Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035, ETrackedDeviceProperty_Prop_DisplaySuppressed_Bool = 2036, + ETrackedDeviceProperty_Prop_DisplayAllowNightMode_Bool = 2037, ETrackedDeviceProperty_Prop_AttachedDeviceId_String = 3000, ETrackedDeviceProperty_Prop_SupportedButtons_Uint64 = 3001, ETrackedDeviceProperty_Prop_Axis0Type_Int32 = 3002, @@ -369,6 +380,7 @@ typedef enum ETrackedPropertyError ETrackedPropertyError_TrackedProp_ValueNotProvidedByDevice = 7, ETrackedPropertyError_TrackedProp_StringExceedsMaximumLength = 8, ETrackedPropertyError_TrackedProp_NotYetAvailable = 9, + ETrackedPropertyError_TrackedProp_PermissionDenied = 10, } ETrackedPropertyError; typedef enum EVRSubmitFlags @@ -376,7 +388,7 @@ typedef enum EVRSubmitFlags EVRSubmitFlags_Submit_Default = 0, EVRSubmitFlags_Submit_LensDistortionAlreadyApplied = 1, EVRSubmitFlags_Submit_GlRenderBuffer = 2, - EVRSubmitFlags_Submit_VulkanTexture = 4, + EVRSubmitFlags_Submit_Reserved = 4, } EVRSubmitFlags; typedef enum EVRState @@ -497,6 +509,7 @@ typedef enum EVREventType EVREventType_VREvent_PerformanceTest_EnableCapture = 1600, EVREventType_VREvent_PerformanceTest_DisableCapture = 1601, EVREventType_VREvent_PerformanceTest_FidelityLevel = 1602, + EVREventType_VREvent_MessageOverlay_Closed = 1650, EVREventType_VREvent_VendorSpecific_Reserved_Start = 10000, EVREventType_VREvent_VendorSpecific_Reserved_End = 19999, } EVREventType; @@ -539,6 +552,13 @@ typedef enum EVRMouseButton EVRMouseButton_VRMouseButton_Middle = 4, } EVRMouseButton; +typedef enum EHiddenAreaMeshType +{ + EHiddenAreaMeshType_k_eHiddenAreaMesh_Standard = 0, + EHiddenAreaMeshType_k_eHiddenAreaMesh_Inverse = 1, + EHiddenAreaMeshType_k_eHiddenAreaMesh_LineLoop = 2, +} EHiddenAreaMeshType; + typedef enum EVRControllerAxisType { EVRControllerAxisType_k_eControllerAxis_None = 0, @@ -584,6 +604,8 @@ typedef enum EVROverlayError EVROverlayError_VROverlayError_UnableToLoadFile = 25, EVROverlayError_VROverlayError_KeyboardAlreadyInUse = 26, EVROverlayError_VROverlayError_NoNeighbor = 27, + EVROverlayError_VROverlayError_TooManyMaskPrimitives = 29, + EVROverlayError_VROverlayError_BadMaskPrimitive = 30, } EVROverlayError; typedef enum EVRApplicationType @@ -651,6 +673,8 @@ typedef enum EVRInitError EVRInitError_VRInitError_Init_InvalidApplicationType = 130, EVRInitError_VRInitError_Init_NotAvailableToWatchdogApps = 131, EVRInitError_VRInitError_Init_WatchdogDisabledInSettings = 132, + EVRInitError_VRInitError_Init_VRDashboardNotFound = 133, + EVRInitError_VRInitError_Init_VRDashboardStartupFailed = 134, EVRInitError_VRInitError_Driver_Failed = 200, EVRInitError_VRInitError_Driver_Unknown = 201, EVRInitError_VRInitError_Driver_HmdUnknown = 202, @@ -797,7 +821,7 @@ typedef enum ChaperoneCalibrationState ChaperoneCalibrationState_Warning_BaseStationRemoved = 102, ChaperoneCalibrationState_Warning_SeatedBoundsInvalid = 103, ChaperoneCalibrationState_Error = 200, - ChaperoneCalibrationState_Error_BaseStationUninitalized = 201, + ChaperoneCalibrationState_Error_BaseStationUninitialized = 201, ChaperoneCalibrationState_Error_BaseStationConflict = 202, ChaperoneCalibrationState_Error_PlayAreaInvalid = 203, ChaperoneCalibrationState_Error_CollisionBoundsInvalid = 204, @@ -826,6 +850,7 @@ typedef enum EVRCompositorError EVRCompositorError_VRCompositorError_TextureUsesUnsupportedFormat = 105, EVRCompositorError_VRCompositorError_SharedTexturesNotSupported = 106, EVRCompositorError_VRCompositorError_IndexOutOfRange = 107, + EVRCompositorError_VRCompositorError_AlreadySubmitted = 108, } EVRCompositorError; typedef enum VROverlayInputMethod @@ -859,8 +884,20 @@ typedef enum VROverlayFlags VROverlayFlags_Panorama = 12, VROverlayFlags_StereoPanorama = 13, VROverlayFlags_SortWithNonSceneOverlays = 14, + VROverlayFlags_VisibleInDashboard = 15, } VROverlayFlags; +typedef enum VRMessageOverlayResponse +{ + VRMessageOverlayResponse_ButtonPress_0 = 0, + VRMessageOverlayResponse_ButtonPress_1 = 1, + VRMessageOverlayResponse_ButtonPress_2 = 2, + VRMessageOverlayResponse_ButtonPress_3 = 3, + VRMessageOverlayResponse_CouldntFindSystemOverlay = 4, + VRMessageOverlayResponse_CouldntFindOrCreateClientOverlay = 5, + VRMessageOverlayResponse_ApplicationQuit = 6, +} VRMessageOverlayResponse; + typedef enum EGamepadTextInputMode { EGamepadTextInputMode_k_EGamepadTextInputModeNormal = 0, @@ -883,6 +920,12 @@ typedef enum EOverlayDirection EOverlayDirection_OverlayDirection_Count = 4, } EOverlayDirection; +typedef enum EVROverlayIntersectionMaskPrimitiveType +{ + EVROverlayIntersectionMaskPrimitiveType_OverlayIntersectionPrimitiveType_Rectangle = 0, + EVROverlayIntersectionMaskPrimitiveType_OverlayIntersectionPrimitiveType_Circle = 1, +} EVROverlayIntersectionMaskPrimitiveType; + typedef enum EVRRenderModelError { EVRRenderModelError_VRRenderModelError_None = 0, @@ -964,7 +1007,6 @@ typedef int32_t TextureID_t; typedef uint32_t VRNotificationId; typedef EVRInitError HmdError; typedef EVREye Hmd_Eye; -typedef EGraphicsAPIConvention GraphicsAPIConvention; typedef EColorSpace ColorSpace; typedef ETrackingResult HmdTrackingResult; typedef ETrackedDeviceClass TrackedDeviceClass; @@ -1048,7 +1090,7 @@ typedef struct DistortionCoordinates_t typedef struct Texture_t { void * handle; // void * - enum EGraphicsAPIConvention eType; + enum ETextureType eType; enum EColorSpace eColorSpace; } Texture_t; @@ -1070,7 +1112,7 @@ typedef struct VRTextureBounds_t float vMax; } VRTextureBounds_t; -typedef struct VulkanData_t +typedef struct VRVulkanTextureData_t { uint64_t m_nImage; struct VkDevice_T * m_pDevice; // struct VkDevice_T * @@ -1082,7 +1124,7 @@ typedef struct VulkanData_t uint32_t m_nHeight; uint32_t m_nFormat; uint32_t m_nSampleCount; -} VulkanData_t; +} VRVulkanTextureData_t; typedef struct VREvent_Controller_t { @@ -1192,6 +1234,11 @@ typedef struct VREvent_EditingCameraSurface_t uint32_t nVisualMode; } VREvent_EditingCameraSurface_t; +typedef struct VREvent_MessageOverlay_t +{ + uint32_t unVRMessageOverlayResponse; +} VREvent_MessageOverlay_t; + typedef struct HiddenAreaMesh_t { struct HmdVector2_t * pVertexData; // const struct vr::HmdVector2_t * @@ -1251,6 +1298,7 @@ typedef struct Compositor_FrameTiming uint32_t m_nSize; uint32_t m_nFrameIndex; uint32_t m_nNumFramePresents; + uint32_t m_nNumMisPresented; uint32_t m_nNumDroppedFrames; uint32_t m_nReprojectionFlags; double m_flSystemTimeInSeconds; @@ -1307,6 +1355,21 @@ typedef struct VROverlayIntersectionResults_t float fDistance; } VROverlayIntersectionResults_t; +typedef struct IntersectionMaskRectangle_t +{ + float m_flTopLeftX; + float m_flTopLeftY; + float m_flWidth; + float m_flHeight; +} IntersectionMaskRectangle_t; + +typedef struct IntersectionMaskCircle_t +{ + float m_flCenterX; + float m_flCenterY; + float m_flRadius; +} IntersectionMaskCircle_t; + typedef struct RenderModel_ComponentState_t { struct HmdMatrix34_t mTrackingToComponentRenderModel; @@ -1396,14 +1459,27 @@ struct VREvent_t }; +typedef union +{ + IntersectionMaskRectangle_t m_Rectangle; + IntersectionMaskCircle_t m_Circle; +} VROverlayIntersectionMaskPrimitive_Data_t; + +struct VROverlayIntersectionMaskPrimitive_t +{ + EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType; + VROverlayIntersectionMaskPrimitive_Data_t m_Primitive; +}; + + // OpenVR Function Pointer Tables struct VR_IVRSystem_FnTable { void (OPENVR_FNTABLE_CALLTYPE *GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight); - struct HmdMatrix44_t (OPENVR_FNTABLE_CALLTYPE *GetProjectionMatrix)(EVREye eEye, float fNearZ, float fFarZ, EGraphicsAPIConvention eProjType); + struct HmdMatrix44_t (OPENVR_FNTABLE_CALLTYPE *GetProjectionMatrix)(EVREye eEye, float fNearZ, float fFarZ); void (OPENVR_FNTABLE_CALLTYPE *GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom); - struct DistortionCoordinates_t (OPENVR_FNTABLE_CALLTYPE *ComputeDistortion)(EVREye eEye, float fU, float fV); + bool (OPENVR_FNTABLE_CALLTYPE *ComputeDistortion)(EVREye eEye, float fU, float fV, struct DistortionCoordinates_t * pDistortionCoordinates); struct HmdMatrix34_t (OPENVR_FNTABLE_CALLTYPE *GetEyeToHeadTransform)(EVREye eEye); bool (OPENVR_FNTABLE_CALLTYPE *GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter); int32_t (OPENVR_FNTABLE_CALLTYPE *GetD3D9AdapterIndex)(); @@ -1431,9 +1507,9 @@ struct VR_IVRSystem_FnTable bool (OPENVR_FNTABLE_CALLTYPE *PollNextEvent)(struct VREvent_t * pEvent, uint32_t uncbVREvent); bool (OPENVR_FNTABLE_CALLTYPE *PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, struct VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose); char * (OPENVR_FNTABLE_CALLTYPE *GetEventTypeNameFromEnum)(EVREventType eType); - struct HiddenAreaMesh_t (OPENVR_FNTABLE_CALLTYPE *GetHiddenAreaMesh)(EVREye eEye); - bool (OPENVR_FNTABLE_CALLTYPE *GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState); - bool (OPENVR_FNTABLE_CALLTYPE *GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, struct TrackedDevicePose_t * pTrackedDevicePose); + struct HiddenAreaMesh_t (OPENVR_FNTABLE_CALLTYPE *GetHiddenAreaMesh)(EVREye eEye, EHiddenAreaMeshType type); + bool (OPENVR_FNTABLE_CALLTYPE *GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize); + bool (OPENVR_FNTABLE_CALLTYPE *GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, struct TrackedDevicePose_t * pTrackedDevicePose); void (OPENVR_FNTABLE_CALLTYPE *TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec); char * (OPENVR_FNTABLE_CALLTYPE *GetButtonIdNameFromEnum)(EVRButtonId eButtonId); char * (OPENVR_FNTABLE_CALLTYPE *GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType); @@ -1458,7 +1534,7 @@ struct VR_IVRTrackedCamera_FnTable char * (OPENVR_FNTABLE_CALLTYPE *GetCameraErrorNameFromEnum)(EVRTrackedCameraError eCameraError); EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *HasCamera)(TrackedDeviceIndex_t nDeviceIndex, bool * pHasCamera); EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *GetCameraFrameSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t * pnWidth, uint32_t * pnHeight, uint32_t * pnFrameBufferSize); - EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *GetCameraIntrinisics)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t * pFocalLength, HmdVector2_t * pCenter); + EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *GetCameraIntrinsics)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t * pFocalLength, HmdVector2_t * pCenter); EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *GetCameraProjection)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t * pProjection); EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *AcquireVideoStreamingService)(TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t * pHandle); EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *ReleaseVideoStreamingService)(TrackedCameraHandle_t hTrackedCamera); @@ -1550,10 +1626,13 @@ struct VR_IVRCompositor_FnTable void (OPENVR_FNTABLE_CALLTYPE *ClearLastSubmittedFrame)(); void (OPENVR_FNTABLE_CALLTYPE *PostPresentHandoff)(); bool (OPENVR_FNTABLE_CALLTYPE *GetFrameTiming)(struct Compositor_FrameTiming * pTiming, uint32_t unFramesAgo); + uint32_t (OPENVR_FNTABLE_CALLTYPE *GetFrameTimings)(struct Compositor_FrameTiming * pTiming, uint32_t nFrames); float (OPENVR_FNTABLE_CALLTYPE *GetFrameTimeRemaining)(); void (OPENVR_FNTABLE_CALLTYPE *GetCumulativeStats)(struct Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes); void (OPENVR_FNTABLE_CALLTYPE *FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground); + struct HmdColor_t (OPENVR_FNTABLE_CALLTYPE *GetCurrentFadeColor)(bool bBackground); void (OPENVR_FNTABLE_CALLTYPE *FadeGrid)(float fSeconds, bool bFadeIn); + float (OPENVR_FNTABLE_CALLTYPE *GetCurrentGridAlpha)(); EVRCompositorError (OPENVR_FNTABLE_CALLTYPE *SetSkyboxOverride)(struct Texture_t * pTextures, uint32_t unTextureCount); void (OPENVR_FNTABLE_CALLTYPE *ClearSkyboxOverride)(); void (OPENVR_FNTABLE_CALLTYPE *CompositorBringToFront)(); @@ -1576,6 +1655,8 @@ struct VR_IVRCompositor_FnTable bool (OPENVR_FNTABLE_CALLTYPE *ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle); void (OPENVR_FNTABLE_CALLTYPE *LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle); void (OPENVR_FNTABLE_CALLTYPE *UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle); + uint32_t (OPENVR_FNTABLE_CALLTYPE *GetVulkanInstanceExtensionsRequired)(char * pchValue, uint32_t unBufferSize); + uint32_t (OPENVR_FNTABLE_CALLTYPE *GetVulkanDeviceExtensionsRequired)(struct VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize); }; struct VR_IVROverlay_FnTable @@ -1636,7 +1717,7 @@ struct VR_IVROverlay_FnTable EVROverlayError (OPENVR_FNTABLE_CALLTYPE *ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle); EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth); EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, char * pchFilePath); - EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, EGraphicsAPIConvention * pAPI, EColorSpace * pColorSpace); + EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, struct VRTextureBounds_t * pTextureBounds); EVROverlayError (OPENVR_FNTABLE_CALLTYPE *ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle); EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight); EVROverlayError (OPENVR_FNTABLE_CALLTYPE *CreateDashboardOverlay)(char * pchOverlayKey, char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle); @@ -1652,6 +1733,9 @@ struct VR_IVROverlay_FnTable void (OPENVR_FNTABLE_CALLTYPE *HideKeyboard)(); void (OPENVR_FNTABLE_CALLTYPE *SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, struct HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform); void (OPENVR_FNTABLE_CALLTYPE *SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, struct HmdRect2_t avoidRect); + EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, struct VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize); + EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags); + VRMessageOverlayResponse (OPENVR_FNTABLE_CALLTYPE *ShowMessageOverlay)(char * pchText, char * pchCaption, char * pchButton0Text, char * pchButton1Text, char * pchButton2Text, char * pchButton3Text); }; struct VR_IVRRenderModels_FnTable diff --git a/third-party/openvr/include/openvr_driver.h b/third-party/openvr/include/openvr_driver.h index 643c117..c2d550e 100644 --- a/third-party/openvr/include/openvr_driver.h +++ b/third-party/openvr/include/openvr_driver.h @@ -111,10 +111,11 @@ enum EVREye Eye_Right = 1 }; -enum EGraphicsAPIConvention +enum ETextureType { - API_DirectX = 0, // Normalized Z goes from 0 at the viewer to 1 at the far clip plane - API_OpenGL = 1, // Normalized Z goes from 1 at the viewer to -1 at the far clip plane + TextureType_DirectX = 0, // Handle is an ID3D11Texture + TextureType_OpenGL = 1, // Handle is an OpenGL texture name or an OpenGL render buffer name, depending on submit flags + TextureType_Vulkan = 2, // Handle is a pointer to a VRVulkanTextureData_t structure }; enum EColorSpace @@ -126,8 +127,8 @@ enum EColorSpace struct Texture_t { - void* handle; // Native d3d texture pointer or GL texture id. - EGraphicsAPIConvention eType; + void* handle; // See ETextureType definition above + ETextureType eType; EColorSpace eColorSpace; }; @@ -146,7 +147,6 @@ enum ETrackingResult TrackingResult_Running_OutOfRange = 201, }; -static const uint32_t k_unTrackingStringSize = 32; static const uint32_t k_unMaxDriverDebugResponseSize = 32768; /** Used to pass device IDs to API calls */ @@ -162,11 +162,8 @@ enum ETrackedDeviceClass TrackedDeviceClass_Invalid = 0, // the ID was not valid. TrackedDeviceClass_HMD = 1, // Head-Mounted Displays TrackedDeviceClass_Controller = 2, // Tracked controllers + TrackedDeviceClass_GenericTracker = 3, // Generic trackers, similar to controllers TrackedDeviceClass_TrackingReference = 4, // Camera and base stations that serve as tracking reference points - - TrackedDeviceClass_Count, // This isn't a class that will ever be returned. It is used for allocating arrays and such - - TrackedDeviceClass_Other = 1000, }; @@ -199,7 +196,7 @@ enum ETrackingUniverseOrigin { TrackingUniverseSeated = 0, // Poses are provided relative to the seated zero pose TrackingUniverseStanding = 1, // Poses are provided relative to the safe bounds configured by the user - TrackingUniverseRawAndUncalibrated = 2, // Poses are provided in the coordinate system defined by the driver. You probably don't want this one. + TrackingUniverseRawAndUncalibrated = 2, // Poses are provided in the coordinate system defined by the driver. It has Y up and is unified for devices of the same driver. You usually don't want this one. }; @@ -207,6 +204,8 @@ enum ETrackingUniverseOrigin * tracked device. Many fields are only valid for one ETrackedDeviceClass. */ enum ETrackedDeviceProperty { + Prop_Invalid = 0, + // general properties that apply to all device classes Prop_TrackingSystemName_String = 1000, Prop_ModelNumber_String = 1001, @@ -241,6 +240,7 @@ enum ETrackedDeviceProperty Prop_HasCamera_Bool = 1030, Prop_DriverVersion_String = 1031, Prop_Firmware_ForceUpdateRequired_Bool = 1032, + Prop_ViveSystemButtonFixRequired_Bool = 1033, // Properties that are unique to TrackedDeviceClass_HMD Prop_ReportsTimeSinceVSync_Bool = 2000, @@ -280,6 +280,7 @@ enum ETrackedDeviceProperty Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034, Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035, Prop_DisplaySuppressed_Bool = 2036, + Prop_DisplayAllowNightMode_Bool = 2037, // Properties that are unique to TrackedDeviceClass_Controller Prop_AttachedDeviceId_String = 3000, @@ -332,6 +333,7 @@ enum ETrackedPropertyError TrackedProp_ValueNotProvidedByDevice = 7, TrackedProp_StringExceedsMaximumLength = 8, TrackedProp_NotYetAvailable = 9, // The property value isn't known yet, but is expected soon. Call again later. + TrackedProp_PermissionDenied = 10, }; /** Allows the application to control what part of the provided texture will be used in the @@ -357,13 +359,13 @@ enum EVRSubmitFlags // If the texture pointer passed in is actually a renderbuffer (e.g. for MSAA in OpenGL) then set this flag. Submit_GlRenderBuffer = 0x02, - // Handle is pointer to VulkanData_t - Submit_VulkanTexture = 0x04, + // Do not use + Submit_Reserved = 0x04, }; /** Data required for passing Vulkan textures to IVRCompositor::Submit. * Be sure to call OpenVR_Shutdown before destroying these resources. */ -struct VulkanData_t +struct VRVulkanTextureData_t { uint64_t m_nImage; // VkImage VkDevice_T *m_pDevice; @@ -516,6 +518,8 @@ enum EVREventType VREvent_PerformanceTest_EnableCapture = 1600, VREvent_PerformanceTest_DisableCapture = 1601, VREvent_PerformanceTest_FidelityLevel = 1602, + + VREvent_MessageOverlay_Closed = 1650, // Vendors are free to expose private events in this reserved region VREvent_VendorSpecific_Reserved_Start = 10000, @@ -702,7 +706,12 @@ struct VREvent_EditingCameraSurface_t uint32_t nVisualMode; }; -/** If you change this you must manually update openvr_interop.cs.py */ +struct VREvent_MessageOverlay_t +{ + uint32_t unVRMessageOverlayResponse; // vr::VRMessageOverlayResponse enum +}; + +/** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py */ typedef union { VREvent_Reserved_t reserved; @@ -723,6 +732,7 @@ typedef union VREvent_ScreenshotProgress_t screenshotProgress; VREvent_ApplicationLaunch_t applicationLaunch; VREvent_EditingCameraSurface_t cameraSurface; + VREvent_MessageOverlay_t messageOverlay; } VREvent_Data_t; /** An event posted by the server to all running applications */ @@ -749,6 +759,14 @@ struct HiddenAreaMesh_t }; +enum EHiddenAreaMeshType +{ + k_eHiddenAreaMesh_Standard = 0, + k_eHiddenAreaMesh_Inverse = 1, + k_eHiddenAreaMesh_LineLoop = 2, +}; + + /** Identifies what kind of axis is on the controller at index n. Read this type * with pVRSystem->Get( nControllerDeviceIndex, Prop_Axis0Type_Int32 + n ); */ @@ -832,26 +850,28 @@ static const VROverlayHandle_t k_ulOverlayHandleInvalid = 0; /** Errors that can occur around VR overlays */ enum EVROverlayError { - VROverlayError_None = 0, + VROverlayError_None = 0, - VROverlayError_UnknownOverlay = 10, - VROverlayError_InvalidHandle = 11, - VROverlayError_PermissionDenied = 12, - VROverlayError_OverlayLimitExceeded = 13, // No more overlays could be created because the maximum number already exist - VROverlayError_WrongVisibilityType = 14, - VROverlayError_KeyTooLong = 15, - VROverlayError_NameTooLong = 16, - VROverlayError_KeyInUse = 17, - VROverlayError_WrongTransformType = 18, - VROverlayError_InvalidTrackedDevice = 19, - VROverlayError_InvalidParameter = 20, - VROverlayError_ThumbnailCantBeDestroyed = 21, - VROverlayError_ArrayTooSmall = 22, - VROverlayError_RequestFailed = 23, - VROverlayError_InvalidTexture = 24, - VROverlayError_UnableToLoadFile = 25, - VROverlayError_KeyboardAlreadyInUse = 26, - VROverlayError_NoNeighbor = 27, + VROverlayError_UnknownOverlay = 10, + VROverlayError_InvalidHandle = 11, + VROverlayError_PermissionDenied = 12, + VROverlayError_OverlayLimitExceeded = 13, // No more overlays could be created because the maximum number already exist + VROverlayError_WrongVisibilityType = 14, + VROverlayError_KeyTooLong = 15, + VROverlayError_NameTooLong = 16, + VROverlayError_KeyInUse = 17, + VROverlayError_WrongTransformType = 18, + VROverlayError_InvalidTrackedDevice = 19, + VROverlayError_InvalidParameter = 20, + VROverlayError_ThumbnailCantBeDestroyed = 21, + VROverlayError_ArrayTooSmall = 22, + VROverlayError_RequestFailed = 23, + VROverlayError_InvalidTexture = 24, + VROverlayError_UnableToLoadFile = 25, + VROverlayError_KeyboardAlreadyInUse = 26, + VROverlayError_NoNeighbor = 27, + VROverlayError_TooManyMaskPrimitives = 29, + VROverlayError_BadMaskPrimitive = 30, }; /** enum values to pass in to VR_Init to identify whether the application will @@ -933,6 +953,8 @@ enum EVRInitError VRInitError_Init_InvalidApplicationType = 130, VRInitError_Init_NotAvailableToWatchdogApps = 131, VRInitError_Init_WatchdogDisabledInSettings = 132, + VRInitError_Init_VRDashboardNotFound = 133, + VRInitError_Init_VRDashboardStartupFailed = 134, VRInitError_Driver_Failed = 200, VRInitError_Driver_Unknown = 201, @@ -1246,7 +1268,6 @@ namespace vr //----------------------------------------------------------------------------- // steamvr keys - static const char * const k_pch_SteamVR_Section = "steamvr"; static const char * const k_pch_SteamVR_RequireHmd_String = "requireHmd"; static const char * const k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver"; @@ -1260,9 +1281,9 @@ namespace vr static const char * const k_pch_SteamVR_LogLevel_Int32 = "loglevel"; static const char * const k_pch_SteamVR_IPD_Float = "ipd"; static const char * const k_pch_SteamVR_Background_String = "background"; + static const char * const k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection"; static const char * const k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight"; static const char * const k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius"; - static const char * const k_pch_SteamVR_Environment_String = "environment"; static const char * const k_pch_SteamVR_GridColor_String = "gridColor"; static const char * const k_pch_SteamVR_PlayAreaColor_String = "playAreaColor"; static const char * const k_pch_SteamVR_ShowStage_Bool = "showStage"; @@ -1275,33 +1296,34 @@ namespace vr static const char * const k_pch_SteamVR_BaseStationPowerManagement_Bool = "basestationPowerManagement"; static const char * const k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses"; static const char * const k_pch_SteamVR_RenderTargetMultiplier_Float = "renderTargetMultiplier"; - static const char * const k_pch_SteamVR_AllowReprojection_Bool = "allowReprojection"; + static const char * const k_pch_SteamVR_AllowAsyncReprojection_Bool = "allowAsyncReprojection"; + static const char * const k_pch_SteamVR_AllowReprojection_Bool = "allowInterleavedReprojection"; static const char * const k_pch_SteamVR_ForceReprojection_Bool = "forceReprojection"; static const char * const k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking"; static const char * const k_pch_SteamVR_DefaultMirrorView_Int32 = "defaultMirrorView"; static const char * const k_pch_SteamVR_ShowMirrorView_Bool = "showMirrorView"; static const char * const k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry"; static const char * const k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch"; + static const char * const k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch"; + static const char * const k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch"; + static const char * const k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard"; static const char * const k_pch_SteamVR_EnableHomeApp = "enableHomeApp"; static const char * const k_pch_SteamVR_SetInitialDefaultHomeApp = "setInitialDefaultHomeApp"; static const char * const k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec"; static const char * const k_pch_SteamVR_RetailDemo_Bool = "retailDemo"; - + static const char * const k_pch_SteamVR_IpdOffset_Float = "ipdOffset"; //----------------------------------------------------------------------------- // lighthouse keys - static const char * const k_pch_Lighthouse_Section = "driver_lighthouse"; static const char * const k_pch_Lighthouse_DisableIMU_Bool = "disableimu"; static const char * const k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation"; static const char * const k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug"; - static const char * const k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation"; static const char * const k_pch_Lighthouse_DBHistory_Bool = "dbhistory"; //----------------------------------------------------------------------------- // null keys - static const char * const k_pch_Null_Section = "driver_null"; static const char * const k_pch_Null_EnableNullDriver_Bool = "enable"; static const char * const k_pch_Null_SerialNumber_String = "serialNumber"; @@ -1319,6 +1341,7 @@ namespace vr // user interface keys static const char * const k_pch_UserInterface_Section = "userinterface"; static const char * const k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop"; + static const char * const k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray"; static const char * const k_pch_UserInterface_Screenshots_Bool = "screenshots"; static const char * const k_pch_UserInterface_ScreenshotType_Int = "screenshotType"; @@ -1542,9 +1565,8 @@ public: /** Returns a string property. If the property is not available this function will return 0 and pError will be * set to an error. Otherwise it returns the length of the number of bytes necessary to hold this string including - * the trailing null. If the buffer is too small the error will be TrackedProp_BufferTooSmall. Strings will - * generally fit in buffers of k_unTrackingStringSize characters. Drivers may not return strings longer than - * k_unMaxPropertyStringSize. */ + * the trailing null. If the buffer is too small the error will be TrackedProp_BufferTooSmall. Drivers may not + * return strings longer than k_unMaxPropertyStringSize. */ virtual uint32_t GetStringTrackedDeviceProperty( ETrackedDeviceProperty prop, char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError ) = 0; }; @@ -1786,6 +1808,10 @@ public: /** Returns true if SteamVR is exiting */ virtual bool IsExiting() = 0; + + /** Returns true and fills the event with the next event on the queue if there is one. If there are no events + * this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */ + virtual bool PollNextEvent( VREvent_t *pEvent, uint32_t uncbVREvent ) = 0; }; @@ -1876,7 +1902,7 @@ public: virtual uint32_t GetStringTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L ) = 0; /** always returns a pointer to a valid interface pointer of IVRSettings */ - virtual IVRSettings *GetSettings( const char *pchInterfaceVersion ) = 0; + virtual void *GetGenericInterface( const char *pchInterfaceVersion ) = 0; /** Client drivers in watchdog mode should call this when they have received a signal from hardware that should * cause SteamVR to start */ @@ -1927,14 +1953,14 @@ public: * This will improve perf by letting the GPU early-reject pixels the user will never see before running the pixel shader. * NOTE: Render this mesh with backface culling disabled since the winding order of the vertices can be different per-HMD or per-eye. */ - virtual HiddenAreaMesh_t GetHiddenAreaMesh( EVREye eEye ) = 0; + virtual HiddenAreaMesh_t GetHiddenAreaMesh( EVREye eEye, EHiddenAreaMeshType type ) = 0; /** Get the MC image for the current HMD. * Returns the size in bytes of the buffer required to hold the specified resource. */ virtual uint32_t GetMCImage( uint32_t *pImgWidth, uint32_t *pImgHeight, uint32_t *pChannels, void *pDataBuffer, uint32_t unBufferLen ) = 0; }; -static const char *IClientTrackedDeviceProvider_Version = "IClientTrackedDeviceProvider_004"; +static const char *IClientTrackedDeviceProvider_Version = "IClientTrackedDeviceProvider_005"; } diff --git a/third-party/openvr/lib/linux64/libopenvr_api.so b/third-party/openvr/lib/linux64/libopenvr_api.so index d8ddc31..4647025 100644 Binary files a/third-party/openvr/lib/linux64/libopenvr_api.so and b/third-party/openvr/lib/linux64/libopenvr_api.so differ diff --git a/third-party/openvr/lib/win32/openvr_api.lib b/third-party/openvr/lib/win32/openvr_api.lib index 8322d9c..1521479 100644 Binary files a/third-party/openvr/lib/win32/openvr_api.lib and b/third-party/openvr/lib/win32/openvr_api.lib differ diff --git a/third-party/openvr/lib/win64/openvr_api.lib b/third-party/openvr/lib/win64/openvr_api.lib index 3ede696..fc16c94 100644 Binary files a/third-party/openvr/lib/win64/openvr_api.lib and b/third-party/openvr/lib/win64/openvr_api.lib differ