add transparency toggle

.gitignore

@@ -1,3 +1,4 @@
 sinpin_vr
 .vscode/
 *.zip
+*.tar.xz

LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ 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.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    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 <https://www.gnu.org/licenses/>.
+
+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:
+
+    <program>  Copyright (C) <year>  <name of author>
+    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
+<https://www.gnu.org/licenses/>.
+
+  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
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

Makefile

@@ -1,18 +1,23 @@
-VERSION=v0.1.0
-# CC := g++
-CC := clang++
-LFLAGS := -lX11 -lXrandr -lglfw -lGL
-LIBS := openvr/libopenvr_api.so
-SRC := src/*.cpp
-OUT := ./sinpin_vr
-CPPFLAGS := -Wall -std=c++17 $(LFLAGS) $(LIBS) $(SRC) -o $(OUT)
+VERSION=v0.2.3
+
+CXX := g++
+# CXX := clang++
+CPPFLAGS := -g -Wall -std=c++17
+LFLAGS := -lX11 -lXrandr -lXtst -lglfw -lGL
+OVR := -Llib -lopenvr_api
+TARGET := ./sinpin_vr
 
 build:
-	$(CC) -g $(CPPFLAGS)
+	$(CXX) src/*.cpp $(CPPFLAGS) $(LFLAGS) -Wl,-rpath,'$$ORIGIN/lib' $(OVR) -o $(TARGET)
 
 release: build
-	zip -r sinpin_vr-$(VERSION).zip sinpin_vr bindings openvr/libopenvr_api.so
+	mkdir -p sinpin-vr/lib
+	cp lib/libopenvr_api.so sinpin-vr/lib
+	cp -r bindings sinpin-vr
+	cp sinpin_vr sinpin-vr
+	tar -caf sinpin-vr-$(VERSION).tar.xz sinpin-vr
+	rm -rf sinpin-vr
 
 run: build
-	$(OUT)
+	$(TARGET)
 

README.md

@@ -1,13 +1,21 @@
 # sinpin-vr
 A SteamVR overlay for Linux+X11 that displays all your screens in VR.
 
-https://user-images.githubusercontent.com/54243225/233798783-27d1a6ae-b71d-448f-bb67-76015e539452.mp4
+https://user-images.githubusercontent.com/54243225/235313348-2ce9b2d8-8458-49f8-ba94-16e577c4f502.mp4
+
+Note: only index controllers have default bindings right now, feel free to make a PR.
 
 ## features
 - one overlay per screen
 - shows cursor position
 - global visibility toggle (default: long press left B)
-- edit mode (default: long press right B)
+- reset positions (default: long press left A)
+- activate cursor input (default: press touchpad)
+	- left mouse default: trigger
+	- right mouse default: A
+	- middle mouse default: not bound
+	- scrolling default: joystick up/down
+- edit mode (default: long press press right B)
 	- move screens around (default: trigger)
 	- resize screens (move with two controllers)
 	- push/pull screens (default: joystick up/down)

bindings/action_manifest.json

@@ -17,30 +17,85 @@
 			"type": "boolean"
 		},
 		{
-			"name": "/actions/main/in/grab",
+			"name": "/actions/main/in/reset",
+			"requirement": "suggested",
+			"type": "boolean"
+		},
+		{
+			"name": "/actions/edit/in/grab",
 			"requirement": "mandatory",
 			"type": "boolean"
 		},
 		{
-			"name": "/actions/main/in/distance",
+			"name": "/actions/edit/in/distance",
 			"requirement": "suggested",
 			"type": "vector2"
+		},
+		{
+			"name": "/actions/cursor/in/activate_cursor",
+			"requirement": "suggested",
+			"type": "boolean"
+		},
+		{
+			"name": "/actions/cursor/in/mouse_left",
+			"requirement": "suggested",
+			"type": "boolean"
+		},
+		{
+			"name": "/actions/cursor/in/mouse_right",
+			"requirement": "suggested",
+			"type": "boolean"
+		},
+		{
+			"name": "/actions/cursor/in/mouse_middle",
+			"requirement": "optional",
+			"type": "boolean"
+		},
+		{
+			"name": "/actions/cursor/in/scroll",
+			"requirement": "suggested",
+			"type": "vector2"
+		},
+		{
+			"name": "/actions/cursor/in/toggle_transparent",
+			"requirement": "suggested",
+			"type": "boolean"
+		},
+		{
+			"name": "/actions/cursor/out/scroll_haptic",
+			"requirement": "suggested",
+			"type": "vibration"
 		}
 	],
 	"action_sets": [
 		{
 			"name": "/actions/main",
 			"usage": "leftright"
+		},
+		{
+			"name": "/actions/edit",
+			"usage": "single"
+		},
+		{
+			"name": "/actions/cursor",
+			"usage": "single"
 		}
 	],
 	"localization": [
 		{
 			"language_tag": "en_us",
-			"/actions/main": "Overlay actions",
-			"/actions/main/in/toggle_visibility": "Toggle visibility",
-			"/actions/main/in/edit_mode": "Toggle edit mode",
-			"/actions/main/in/grab": "grab panel",
-			"/actions/main/in/distance": "Move away"
+			"/actions/main/in/toggle_visibility": "toggle visibility",
+			"/actions/main/in/edit_mode": "toggle edit mode",
+			"/actions/main/in/reset": "reset positions",
+			"/actions/edit/in/grab": "grab panel",
+			"/actions/edit/in/distance": "push/pull overlay",
+			"/actions/cursor/in/activate_cursor": "activate cursor",
+			"/actions/cursor/in/mouse_left": "left mouse button",
+			"/actions/cursor/in/mouse_right": "right mouse button",
+			"/actions/cursor/in/mouse_middle": "middle mouse button",
+			"/actions/cursor/in/scroll": "scroll",
+			"/actions/cursor/in/toggle_transparent": "toggle transparency",
+			"/actions/cursor/out/scroll_haptic": "scrolling haptic feedback"
 		}
 	]
 }

bindings/index_controller.json

@@ -138,8 +138,134 @@
          "hidden" : true
       }
    },
-   "app_key" : "system.generated.overlay",
+   "app_key" : "system.generated.sinpin_vr",
    "bindings" : {
+      "/actions/cursor" : {
+         "haptics" : [
+            {
+               "output" : "/actions/cursor/out/scroll_haptic",
+               "path" : "/user/hand/left/output/haptic"
+            },
+            {
+               "output" : "/actions/cursor/out/scroll_haptic",
+               "path" : "/user/hand/right/output/haptic"
+            }
+         ],
+         "sources" : [
+            {
+               "inputs" : {
+                  "click" : {
+                     "output" : "/actions/cursor/in/mouse_right"
+                  }
+               },
+               "mode" : "button",
+               "path" : "/user/hand/left/input/a"
+            },
+            {
+               "inputs" : {
+                  "click" : {
+                     "output" : "/actions/cursor/in/mouse_right"
+                  }
+               },
+               "mode" : "button",
+               "path" : "/user/hand/right/input/a"
+            },
+            {
+               "inputs" : {
+                  "click" : {
+                     "output" : "/actions/cursor/in/mouse_left"
+                  }
+               },
+               "mode" : "button",
+               "path" : "/user/hand/left/input/trigger"
+            },
+            {
+               "inputs" : {
+                  "click" : {
+                     "output" : "/actions/cursor/in/mouse_left"
+                  }
+               },
+               "mode" : "button",
+               "path" : "/user/hand/right/input/trigger"
+            },
+            {
+               "inputs" : {
+                  "click" : {
+                     "output" : "/actions/cursor/in/activate_cursor"
+                  }
+               },
+               "mode" : "button",
+               "path" : "/user/hand/left/input/trackpad"
+            },
+            {
+               "inputs" : {
+                  "click" : {
+                     "output" : "/actions/cursor/in/activate_cursor"
+                  }
+               },
+               "mode" : "button",
+               "path" : "/user/hand/right/input/trackpad"
+            },
+            {
+               "inputs" : {
+                  "position" : {
+                     "output" : "/actions/cursor/in/scroll"
+                  }
+               },
+               "mode" : "joystick",
+               "path" : "/user/hand/left/input/thumbstick"
+            },
+            {
+               "inputs" : {
+                  "position" : {
+                     "output" : "/actions/cursor/in/scroll"
+                  }
+               },
+               "mode" : "joystick",
+               "path" : "/user/hand/right/input/thumbstick"
+            }
+         ]
+      },
+      "/actions/edit" : {
+         "sources" : [
+            {
+               "inputs" : {
+                  "position" : {
+                     "output" : "/actions/edit/in/distance"
+                  }
+               },
+               "mode" : "joystick",
+               "path" : "/user/hand/left/input/thumbstick"
+            },
+            {
+               "inputs" : {
+                  "position" : {
+                     "output" : "/actions/edit/in/distance"
+                  }
+               },
+               "mode" : "joystick",
+               "path" : "/user/hand/right/input/thumbstick"
+            },
+            {
+               "inputs" : {
+                  "click" : {
+                     "output" : "/actions/edit/in/grab"
+                  }
+               },
+               "mode" : "button",
+               "path" : "/user/hand/left/input/trigger"
+            },
+            {
+               "inputs" : {
+                  "click" : {
+                     "output" : "/actions/edit/in/grab"
+                  }
+               },
+               "mode" : "button",
+               "path" : "/user/hand/right/input/trigger"
+            }
+         ]
+      },
       "/actions/legacy" : {
          "haptics" : [
             {
@@ -591,41 +717,17 @@
             {
                "inputs" : {
                   "long" : {
-                     "output" : "/actions/main/in/edit_mode"
+                     "output" : "/actions/main/in/reset"
                   }
                },
                "mode" : "button",
-               "path" : "/user/hand/right/input/b"
-            },
-            {
-               "inputs" : {
-                  "position" : {
-                     "output" : "/actions/main/in/distance"
-                  }
-               },
-               "mode" : "joystick",
-               "path" : "/user/hand/right/input/thumbstick"
+               "path" : "/user/hand/left/input/a"
             },
             {
                "inputs" : {
                   "click" : {
-                     "output" : "/actions/main/in/grab"
-                  }
-               },
-               "mode" : "button",
-               "path" : "/user/hand/right/input/trigger"
-            },
-            {
-               "inputs" : {
-                  "click" : {
-                     "output" : "/actions/main/in/grab"
-                  }
-               },
-               "mode" : "button",
-               "path" : "/user/hand/left/input/trigger"
-            },
-            {
-               "inputs" : {
+                     "output" : "/actions/main/in/mouse_left"
+                  },
                   "long" : {
                      "output" : "/actions/main/in/toggle_visibility"
                   }
@@ -635,21 +737,21 @@
             },
             {
                "inputs" : {
-                  "position" : {
-                     "output" : "/actions/main/in/distance"
+                  "long" : {
+                     "output" : "/actions/main/in/edit_mode"
                   }
                },
-               "mode" : "joystick",
-               "path" : "/user/hand/left/input/thumbstick"
+               "mode" : "button",
+               "path" : "/user/hand/right/input/b"
             }
          ]
       }
    },
    "category" : "steamvr_input",
    "controller_type" : "knuckles",
-   "description" : "Default binding values for legacy apps using the Index Controller",
+   "description" : "yes",
    "interaction_profile" : "",
-   "name" : "Saved overlay configuration for Index Controller",
+   "name" : "Default sinpin_vr bindings",
    "options" : {
       "mirror_actions" : true,
       "simulated_controller_type" : "none"

src/app.cpp

@@ -1,10 +1,17 @@
 #include "app.h"
 #include "controller.h"
 #include "util.h"
+#include <X11/Xlib.h>
+#include <X11/extensions/XTest.h>
 #include <X11/extensions/Xrandr.h>
 #include <cassert>
 #include <glm/matrix.hpp>
 
+const VRMat root_start_pose = {{{1, 0, 0, 0}, {0, 1, 0, 0.8f}, {0, 0, 1, 0}}}; // 0.8m above origin
+
+const int FRAME_INTERVAL = 4; // number of update loops until the frame buffer is updated
+const float TRANSPARENCY = 0.6f;
+
 App::App()
 {
 	_tracking_origin = vr::TrackingUniverseStanding;
@@ -26,9 +33,9 @@ App::App()
 	XRRMonitorInfo *monitor_info = XRRGetMonitors(_xdisplay, _root_window, 1, &monitor_count);
 	printf("found %d monitors:\n", monitor_count);
 
-	float pixels_per_meter = 1920;
-	float total_width_meters = _root_width / pixels_per_meter;
-	float total_height_meters = _root_height / pixels_per_meter;
+	_pixels_per_meter = 1920;
+	_total_width_meters = _root_width / _pixels_per_meter;
+	_total_height_meters = _root_height / _pixels_per_meter;
 
 	for (int i = 0; i < monitor_count; i++)
 	{
@@ -36,14 +43,6 @@ App::App()
 		printf("screen %d: pos(%d, %d) %dx%d\n", i, mon.x, mon.y, mon.width, mon.height);
 
 		_panels.push_back(Panel(this, i, mon.x, mon.y, mon.width, mon.height));
-
-		float width = mon.width / pixels_per_meter;
-		float pos_x = mon.x / pixels_per_meter + width / 2.0f - total_width_meters / 2.0f;
-		float height = mon.height / pixels_per_meter;
-		float pos_y = 1.2f + mon.y / pixels_per_meter - height / 2.0f + total_height_meters / 2.0f;
-		VRMat start_pose = {{{1, 0, 0, pos_x}, {0, 1, 0, pos_y}, {0, 0, 1, 0}}};
-		_panels[i].GetOverlay()->SetTransformWorld(&start_pose);
-		_panels[i].GetOverlay()->SetWidth(width);
 	}
 
 	for (auto &panel : _panels)
@@ -57,15 +56,35 @@ App::App()
 		printf("actions path: %s\n", _actions_path.c_str());
 		vr_input->SetActionManifestPath(_actions_path.c_str());
 
-		auto action_err = vr_input->GetActionHandle("/actions/main/in/grab", &_input_handles.grab);
+		auto action_err = vr_input->GetActionHandle("/actions/edit/in/grab", &_input_handles.edit.grab);
 		assert(action_err == 0);
-		action_err = vr_input->GetActionHandle("/actions/main/in/toggle_visibility", &_input_handles.toggle_hidden);
+		action_err = vr_input->GetActionHandle("/actions/main/in/toggle_visibility", &_input_handles.main.toggle_hidden);
 		assert(action_err == 0);
-		action_err = vr_input->GetActionHandle("/actions/main/in/edit_mode", &_input_handles.edit_mode);
+		action_err = vr_input->GetActionHandle("/actions/cursor/in/activate_cursor", &_input_handles.cursor.activate);
 		assert(action_err == 0);
-		action_err = vr_input->GetActionHandle("/actions/main/in/distance", &_input_handles.distance);
+		action_err = vr_input->GetActionHandle("/actions/main/in/edit_mode", &_input_handles.main.edit_mode);
 		assert(action_err == 0);
-		action_err = vr_input->GetActionSetHandle("/actions/main", &_input_handles.set);
+		action_err = vr_input->GetActionHandle("/actions/main/in/reset", &_input_handles.main.reset);
+		assert(action_err == 0);
+		action_err = vr_input->GetActionHandle("/actions/edit/in/distance", &_input_handles.edit.distance);
+		assert(action_err == 0);
+		action_err = vr_input->GetActionHandle("/actions/cursor/in/mouse_left", &_input_handles.cursor.mouse_left);
+		assert(action_err == 0);
+		action_err = vr_input->GetActionHandle("/actions/cursor/in/mouse_right", &_input_handles.cursor.mouse_right);
+		assert(action_err == 0);
+		action_err = vr_input->GetActionHandle("/actions/cursor/in/mouse_middle", &_input_handles.cursor.mouse_middle);
+		assert(action_err == 0);
+		action_err = vr_input->GetActionHandle("/actions/cursor/in/scroll", &_input_handles.cursor.scroll);
+		assert(action_err == 0);
+		action_err = vr_input->GetActionHandle("/actions/cursor/in/toggle_transparent", &_input_handles.cursor.toggle_transparent);
+		assert(action_err == 0);
+		action_err = vr_input->GetActionHandle("/actions/cursor/out/scroll_haptic", &_input_handles.cursor.scroll_haptic);
+		assert(action_err == 0);
+		action_err = vr_input->GetActionSetHandle("/actions/main", &_input_handles.main_set);
+		assert(action_err == 0);
+		action_err = vr_input->GetActionSetHandle("/actions/edit", &_input_handles.edit_set);
+		assert(action_err == 0);
+		action_err = vr_input->GetActionSetHandle("/actions/cursor", &_input_handles.cursor_set);
 		assert(action_err == 0);
 	}
 }
@@ -75,6 +94,7 @@ App::~App()
 	vr::VR_Shutdown();
 	glfwDestroyWindow(_gl_window);
 	glfwTerminate();
+	XCloseDisplay(_xdisplay);
 }
 
 void App::InitX11()
@@ -124,20 +144,15 @@ void App::InitRootOverlay()
 {
 	_root_overlay = Overlay(this, "root");
 	_root_overlay.SetAlpha(0.5f);
-	// clang-format off
-	VRMat root_start_pose = {{
-		{0.25f,	0.0f,	0.0f, 0},
-		{0.0f,	0.25f,	0.0f, 0.8f},
-		{0.0f,	0.0f,	1.0f, 0}
-	}};
-	// clang-format on
+	_root_overlay.SetWidth(0.25f);
 	_root_overlay.SetTransformWorld(&root_start_pose);
 	_root_overlay.SetTextureToColor(110, 30, 190);
+	_root_overlay.SetHidden(true);
 }
 
-void App::Update()
+void App::Update(float dtime)
 {
-	UpdateInput();
+	UpdateInput(dtime);
 	if (!_hidden)
 	{
 		_root_overlay.Update();
@@ -150,48 +165,86 @@ void App::Update()
 	_frames_since_framebuffer += 1;
 }
 
-void App::UpdateInput()
+void App::UpdateInput(float dtime)
 {
-	vr::VRActiveActionSet_t main;
-	main.ulActionSet = _input_handles.set;
-	main.ulRestrictedToDevice = 0;
-	main.nPriority = 10;
-	vr::EVRInputError err = vr_input->UpdateActionState(&main, sizeof(vr::VRActiveActionSet_t), 1);
-	if (err)
+	vr::VRActiveActionSet_t active_sets[2];
+	active_sets[0].ulActionSet = _input_handles.main_set;
+	active_sets[0].ulRestrictedToDevice = 0;
+	active_sets[0].nPriority = 10;
+	int set_count = 1;
+	if (!_hidden)
 	{
-		printf("Error: (update action state): %d\n", err);
+		set_count = 2;
+		active_sets[1].ulRestrictedToDevice = 0;
+		active_sets[1].nPriority = 10;
+		active_sets[1].ulActionSet = _input_handles.cursor_set;
+		if (_edit_mode)
+			active_sets[1].ulActionSet = _input_handles.edit_set;
 	}
+	vr::EVRInputError err = vr_input->UpdateActionState(active_sets, sizeof(vr::VRActiveActionSet_t), set_count);
+	if (err)
+		printf("Error updating action state: %d\n", err);
 
 	vr_sys->GetDeviceToAbsoluteTrackingPose(_tracking_origin, 0, _tracker_poses, MAX_TRACKERS);
 
-	if (IsInputJustPressed(_input_handles.toggle_hidden))
+	if (IsInputJustPressed(_input_handles.main.toggle_hidden))
 	{
 		_hidden = !_hidden;
 		for (auto &panel : _panels)
 		{
 			panel.SetHidden(_hidden);
 		}
-		_root_overlay.SetHidden(_hidden || !_edit_mode);
-		_controllers[0]->SetHidden(_hidden || !_edit_mode);
-		_controllers[1]->SetHidden(_hidden || !_edit_mode);
+		UpdateUIVisibility();
 	}
-	if (!_hidden && IsInputJustPressed(_input_handles.edit_mode))
+	if (IsInputJustPressed(_input_handles.cursor.toggle_transparent))
 	{
-		_edit_mode = !_edit_mode;
-		_root_overlay.SetHidden(_hidden || !_edit_mode);
-		_controllers[0]->SetHidden(_hidden || !_edit_mode);
-		_controllers[1]->SetHidden(_hidden || !_edit_mode);
+		_transparent = !_transparent;
+		if (_transparent)
+		{
+			for (auto &panel : _panels)
+				panel.GetOverlay()->SetAlpha(TRANSPARENCY);
+		}
+		else
+		{
+			for (auto &panel : _panels)
+				panel.GetOverlay()->SetAlpha(1);
+		}
 	}
-	if (_edit_mode)
+	if (!_hidden)
 	{
-		_controllers[0]->Update();
-		_controllers[1]->Update();
+		if (IsInputJustPressed(_input_handles.main.reset))
+		{
+			_root_overlay.SetTransformWorld(&root_start_pose);
+			_root_overlay.SetWidth(0.25f);
+			for (auto &panel : _panels)
+			{
+				panel.ResetTransform();
+			}
+		}
+		if (IsInputJustPressed(_input_handles.main.edit_mode))
+		{
+			_edit_mode = !_edit_mode;
+			UpdateUIVisibility();
+			if (_edit_mode && _active_cursor.has_value())
+			{
+				_active_cursor.value()->_cursor_active = false;
+				_active_cursor = {};
+			}
+		}
 	}
+	_controllers[0]->Update(dtime);
+	_controllers[1]->Update(dtime);
+}
+
+void App::UpdateUIVisibility()
+{
+	bool state = _hidden || !_edit_mode;
+	_root_overlay.SetHidden(state);
 }
 
 void App::UpdateFramebuffer()
 {
-	if (_frames_since_framebuffer < 2)
+	if (_frames_since_framebuffer < FRAME_INTERVAL)
 	{
 		return;
 	}
@@ -255,7 +308,7 @@ Ray App::IntersectRay(glm::vec3 origin, glm::vec3 direction, float max_len)
 
 	for (auto &panel : _panels)
 	{
-		auto r_panel = panel.GetOverlay()->IntersectRay(origin, direction, max_len);
+		auto r_panel = panel.IntersectRay(origin, direction, max_len);
 		if (r_panel.distance < ray.distance)
 		{
 			ray = r_panel;
@@ -281,3 +334,14 @@ CursorPos App::GetCursorPosition()
 		&buttons);
 	return pos;
 }
+
+void App::SetCursor(int x, int y)
+{
+	// I don't know what the return value of XWarpPointer means, it seems to be 1 on success.
+	XWarpPointer(_xdisplay, _root_window, _root_window, 0, 0, _root_width, _root_height, x, y);
+}
+
+void App::SendMouseInput(unsigned int button, bool state)
+{
+	XTestFakeButtonEvent(_xdisplay, button, state, 0);
+}

src/app.h

@@ -18,11 +18,30 @@ struct CursorPos
 
 struct InputHandles
 {
-	vr::VRActionSetHandle_t set;
-	vr::VRActionHandle_t toggle_hidden;
-	vr::VRActionHandle_t distance;
-	vr::VRActionHandle_t grab;
-	vr::VRActionHandle_t edit_mode;
+	struct
+	{
+		vr::VRActionHandle_t toggle_hidden;
+		vr::VRActionHandle_t edit_mode;
+		vr::VRActionHandle_t reset;
+	} main;
+	vr::VRActionSetHandle_t main_set;
+	struct
+	{
+		vr::VRActionHandle_t activate;
+		vr::VRActionHandle_t mouse_left;
+		vr::VRActionHandle_t mouse_right;
+		vr::VRActionHandle_t mouse_middle;
+		vr::VRActionHandle_t scroll;
+		vr::VRActionHandle_t scroll_haptic;
+		vr::VRActionHandle_t toggle_transparent;
+	} cursor;
+	vr::VRActionSetHandle_t cursor_set;
+	struct
+	{
+		vr::VRActionHandle_t distance;
+		vr::VRActionHandle_t grab;
+	} edit;
+	vr::VRActionSetHandle_t edit_set;
 };
 
 class App
@@ -30,7 +49,7 @@ class App
   public:
 	App();
 	~App();
-	void Update();
+	void Update(float dtime);
 
 	std::vector<TrackerID> GetControllers();
 	glm::mat4 GetTrackerPose(TrackerID tracker);
@@ -40,6 +59,8 @@ class App
 	CursorPos GetCursorPosition();
 
 	Ray IntersectRay(glm::vec3 origin, glm::vec3 direction, float max_len);
+	void SetCursor(int x, int y);
+	void SendMouseInput(unsigned int button, bool state);
 
 	Display *_xdisplay;
 	Window _root_window;
@@ -49,6 +70,9 @@ class App
 
 	int _root_width;
 	int _root_height;
+	float _pixels_per_meter;
+	float _total_height_meters;
+	float _total_width_meters;
 
 	vr::ETrackingUniverseOrigin _tracking_origin;
 	std::filesystem::path _actions_path;
@@ -64,7 +88,9 @@ class App
 	Overlay _root_overlay;
 	std::vector<Panel> _panels;
 	bool _hidden = false;
+	bool _transparent = false;
 	bool _edit_mode = false;
+	std::optional<Controller *> _active_cursor;
 
   private:
 	void InitX11();
@@ -73,5 +99,6 @@ class App
 	void InitRootOverlay();
 
 	void UpdateFramebuffer();
-	void UpdateInput();
+	void UpdateInput(float dtime);
+	void UpdateUIVisibility();
 };

src/controller.cpp

@@ -4,7 +4,13 @@
 #include "util.h"
 #include <string>
 
-const float width = 0.004f;
+const float LASER_WIDTH = 0.004f;
+const Color EDIT_COLOR{1, 0.6f, 1};
+const Color CURSOR_COLOR{0.3f, 1, 1};
+const float SCROLL_SPEED = 48;
+const float SCROLL_HAPTIC_STRENGTH = 0.15f;
+const float SCROLL_HAPTIC_TIME = 0.1f;
+const float MOUSE_DRAG_THRESHOLD = 48;
 
 Controller::Controller(App *app, ControllerSide side)
 {
@@ -13,7 +19,6 @@ Controller::Controller(App *app, ControllerSide side)
 	_input_handle = 0;
 	_is_connected = false;
 	_side = side;
-	_hidden = false;
 
 	std::string laser_name = "controller_laser_";
 	if (side == ControllerSide::Left)
@@ -23,7 +28,7 @@ Controller::Controller(App *app, ControllerSide side)
 
 	_laser = Overlay(app, laser_name);
 	UpdateStatus();
-	_laser.SetTextureToColor(255, 200, 255);
+	_laser.SetTextureToColor(255, 255, 255);
 	_laser.SetAlpha(0.2f);
 	_laser.SetHidden(true);
 }
@@ -48,12 +53,6 @@ bool Controller::IsConnected()
 	return _is_connected;
 }
 
-void Controller::SetHidden(bool state)
-{
-	_hidden = state;
-	_laser.SetHidden(_hidden);
-}
-
 void Controller::ReleaseOverlay()
 {
 	_grabbed_overlay = nullptr;
@@ -74,20 +73,117 @@ glm::vec3 Controller::GetLastRot()
 	return _last_rotation;
 }
 
-void Controller::Update()
+void Controller::Update(float dtime)
 {
 	UpdateStatus();
-	if (!_is_connected || _hidden)
+	if (!_is_connected)
 		return;
 
 	UpdateLaser();
 
-	float move = _app->GetInputAnalog(_app->_input_handles.distance, _input_handle).y * 0.1; // TODO use frame time
-	if (_grabbed_overlay && move != 0.0f)
+	if (_app->_edit_mode)
 	{
-		auto transform = _grabbed_overlay->GetTarget()->transform;
-		transform.m[2][3] = glm::clamp(transform.m[2][3] - move, -5.0f, -0.1f); // moving along z axis
-		_grabbed_overlay->SetTransformTracker(_device_index, &transform);
+		_laser.SetColor(EDIT_COLOR);
+		if (_last_ray.overlay != nullptr)
+		{
+			auto ray = _last_ray;
+			if (_app->IsInputJustPressed(_app->_input_handles.edit.grab, _input_handle))
+			{
+				if (ray.overlay->IsHeld())
+				{
+					ray.overlay->ControllerResize(this);
+				}
+				else
+				{
+					_grabbed_overlay = ray.overlay;
+					ray.overlay->ControllerGrab(this);
+				}
+			}
+		}
+
+		if (_grabbed_overlay != nullptr)
+		{
+			float move = _app->GetInputAnalog(_app->_input_handles.edit.distance, _input_handle).y * dtime * 8;
+			if (move != 0.0f)
+			{
+				auto transform = _grabbed_overlay->GetTarget()->transform;
+				transform.m[2][3] = glm::clamp(transform.m[2][3] - move, -5.0f, -0.1f); // moving along z axis
+				_grabbed_overlay->SetTransformTracker(_device_index, &transform);
+			}
+		}
+	}
+	else // cursor mode
+	{
+		if (_app->IsInputJustPressed(_app->_input_handles.cursor.activate, _input_handle))
+		{
+			if (!_cursor_active && _app->_active_cursor.has_value())
+			{
+				_app->_active_cursor.value()->_cursor_active = false;
+				_app->_active_cursor = this;
+			}
+			_cursor_active = !_cursor_active;
+			_app->_active_cursor = this;
+			_laser.SetColor(CURSOR_COLOR);
+		}
+		if (_cursor_active)
+		{
+			if (_last_ray.overlay != nullptr && _last_ray.hit_panel != nullptr)
+			{
+				auto pos = glm::vec2(_last_ray.local_pos.x, _last_ray.local_pos.y);
+				// normalize positions to +-0.5
+				pos /= _last_ray.overlay->Width();
+				pos.y *= -1;
+
+				// shift to 0-1
+				pos.x += 0.5f;
+				pos.y += 0.5f * _last_ray.overlay->Ratio();
+
+				pos *= _last_ray.hit_panel->Width();
+				if (glm::length(pos - _last_set_mouse_pos) > MOUSE_DRAG_THRESHOLD)
+				{
+					_mouse_drag_lock = false;
+				}
+				if (!_mouse_drag_lock)
+				{
+					_last_ray.hit_panel->SetCursor(pos.x, pos.y);
+					_last_set_mouse_pos = pos;
+				}
+			}
+			UpdateMouseButton(_app->_input_handles.cursor.mouse_left, 1);
+			UpdateMouseButton(_app->_input_handles.cursor.mouse_middle, 2);
+			UpdateMouseButton(_app->_input_handles.cursor.mouse_right, 3);
+			auto scroll_state = _app->GetInputAnalog(_app->_input_handles.cursor.scroll, _input_handle);
+			if (scroll_state.y != 0)
+			{
+				_last_sent_scroll += dtime * glm::abs(scroll_state.y) * SCROLL_SPEED;
+				if (_last_sent_scroll > 1)
+				{
+					_last_sent_scroll = 0;
+					if (scroll_state.y > 0)
+					{
+						_app->SendMouseInput(4, true);
+						_app->SendMouseInput(4, false);
+						_app->vr_input->TriggerHapticVibrationAction(_app->_input_handles.cursor.scroll_haptic, 0, SCROLL_HAPTIC_TIME, 1 / SCROLL_HAPTIC_TIME, SCROLL_HAPTIC_STRENGTH, _input_handle);
+					}
+					else if (scroll_state.y < 0)
+					{
+						_app->SendMouseInput(5, true);
+						_app->SendMouseInput(5, false);
+						_app->vr_input->TriggerHapticVibrationAction(_app->_input_handles.cursor.scroll_haptic, 0, SCROLL_HAPTIC_TIME, 1 / SCROLL_HAPTIC_TIME, SCROLL_HAPTIC_STRENGTH, _input_handle);
+					}
+				}
+			}
+		}
+	}
+}
+
+void Controller::UpdateMouseButton(vr::VRActionHandle_t binding, unsigned int button)
+{
+	auto state = _app->GetInputDigital(binding, _input_handle);
+	if (state.bChanged)
+	{
+		_app->SendMouseInput(button, state.bState);
+		_mouse_drag_lock = state.bState;
 	}
 }
 
@@ -108,24 +204,9 @@ void Controller::UpdateLaser()
 	hmd_local_pos.z = 0;
 	auto hmd_dir = glm::normalize(hmd_local_pos);
 
-	VRMat transform = {{{width * hmd_dir.y, 0, width * hmd_dir.x, 0}, {width * -hmd_dir.x, 0, width * hmd_dir.y, 0}, {0, len, 0, len * -0.5f}}};
+	VRMat transform = {{{LASER_WIDTH * hmd_dir.y, 0, LASER_WIDTH * hmd_dir.x, 0}, {LASER_WIDTH * -hmd_dir.x, 0, LASER_WIDTH * hmd_dir.y, 0}, {0, len, 0, len * -0.5f}}};
 	_laser.SetTransformTracker(_device_index, &transform);
-
-	if (ray.overlay != nullptr)
-	{
-		if (_app->IsInputJustPressed(_app->_input_handles.grab, _input_handle))
-		{
-			if (ray.overlay->IsHeld())
-			{
-				ray.overlay->ControllerResize(this);
-			}
-			else
-			{
-				_grabbed_overlay = ray.overlay;
-				ray.overlay->ControllerGrab(this);
-			}
-		}
-	}
+	_laser.SetHidden(!_is_connected || _app->_hidden || (!_app->_edit_mode && !_cursor_active));
 }
 
 void Controller::UpdateStatus()
@@ -145,8 +226,4 @@ void Controller::UpdateStatus()
 		_device_index = _app->vr_sys->GetTrackedDeviceIndexForControllerRole(vr::TrackedControllerRole_RightHand);
 	}
 	_is_connected &= _device_index < MAX_TRACKERS;
-	if (!_is_connected)
-	{
-		_laser.SetHidden(true);
-	}
 }

src/controller.h

@@ -24,25 +24,33 @@ class Controller
 	glm::vec3 GetLastPos();
 	glm::vec3 GetLastRot();
 
-	void SetHidden(bool state);
-
 	void ReleaseOverlay();
 
-	void Update();
+	void Update(float dtime);
+
+	bool _cursor_active = false;
 
   private:
 	void UpdateStatus();
 	void UpdateLaser();
 
+	void UpdateMouseButton(vr::VRActionHandle_t binding, unsigned int button);
+
 	App *_app;
 	Overlay _laser;
 	ControllerSide _side;
 	TrackerID _device_index;
 	vr::VRInputValueHandle_t _input_handle;
+
 	bool _is_connected;
-	bool _hidden;
+
 	Overlay *_grabbed_overlay;
+
 	Ray _last_ray;
 	glm::vec3 _last_rotation;
 	glm::vec3 _last_pos;
+
+	float _last_sent_scroll = 0;
+	bool _mouse_drag_lock = false;
+	glm::vec2 _last_set_mouse_pos;
 };

src/main.cpp

@@ -1,7 +1,7 @@
 #include "app.h"
 #include <signal.h>
 
-#define UPDATE_RATE 60
+#define UPDATE_RATE 120
 
 bool should_exit = false;
 
@@ -18,8 +18,8 @@ int main()
 
 	while (!should_exit)
 	{
-		app.Update();
 		usleep(1000000 / UPDATE_RATE);
+		app.Update(1.0 / UPDATE_RATE);
 	}
 	printf("\nShutting down\n");
 	return 0;

src/overlay.cpp

@@ -108,6 +108,17 @@ void Overlay::SetTextureToColor(uint8_t r, uint8_t g, uint8_t b)
 	assert(set_texture_err == 0);
 }
 
+void Overlay::SetColor(float r, float g, float b)
+{
+	auto set_color_err = _app->vr_overlay->SetOverlayColor(_id, r, g, b);
+	assert(set_color_err == 0);
+}
+
+void Overlay::SetColor(Color c)
+{
+	SetColor(c.r, c.g, c.b);
+}
+
 void Overlay::SetTransformTracker(TrackerID tracker, const VRMat *transform)
 {
 	auto original_pose = _target.transform;
@@ -148,28 +159,29 @@ void Overlay::SetTargetWorld()
 	SetTransformWorld(&abs_pose);
 }
 
-Ray Overlay::IntersectRay(glm::vec3 origin, glm::vec3 direction, float max_len)
+Ray Overlay::IntersectRay(glm::vec3 ray_start_g, glm::vec3 direction, float max_len)
 {
 	float dist = max_len;
-	auto end = origin + direction * max_len;
+	auto ray_end_g = ray_start_g + direction * max_len;
 
 	auto panel_transform = GetTransformAbsolute();
 	auto panel_pos = GetPos(panel_transform);
-	auto a = glm::inverse(panel_transform) * glm::vec4(origin - panel_pos, 0);
-	auto b = glm::inverse(panel_transform) * glm::vec4(end - panel_pos, 0);
-	float r = a.z / (a.z - b.z);
-	auto p = a + (b - a) * r;
-	// printf("panel pos: (%.2f,%.2f,%.2f)\n", panel_pos.x, panel_pos.y, panel_pos.z);
-	// printf("a: (%.2f,%.2f,%.2f)\n", a.x, a.y, a.z);
-	// printf("b: (%.2f,%.2f,%.2f)\n", b.x, b.y, b.z);
-	// printf("r: %.2f\n", r);
-	// printf("p: (%.2f,%.2f,%.2f)\n", p.x, p.y, p.z);
+	auto ray_start = glm::inverse(panel_transform) * glm::vec4(ray_start_g - panel_pos, 0);
+	auto ray_end = glm::inverse(panel_transform) * glm::vec4(ray_end_g - panel_pos, 0);
+	float length_frac = ray_start.z / (ray_start.z - ray_end.z);
+	auto hit_pos = ray_start + (ray_end - ray_start) * length_frac;
 
-	if (b.z < a.z && b.z < 0 && glm::abs(p.x) < (_width_m * 0.5f) && glm::abs(p.y) < (_width_m * 0.5f * _ratio))
+	// clang-format off
+	if (ray_end.z < ray_start.z
+		&& ray_end.z < 0
+		&& glm::abs(hit_pos.x) < (_width_m * 0.5f)
+		&& glm::abs(hit_pos.y) < (_width_m * 0.5f * _ratio)
+		&& length_frac > 0)
 	{
-		dist = glm::min(r * max_len, max_len);
+		// clang-format on
+		dist = glm::min(length_frac * max_len, max_len);
 	}
-	return Ray{.overlay = this, .distance = dist};
+	return Ray{.overlay = this, .distance = dist, .local_pos = hit_pos, .hit_panel = nullptr};
 }
 
 glm::mat4x4 Overlay::GetTransformAbsolute()
@@ -208,10 +220,10 @@ void Overlay::Update()
 
 	if (_holding_controller != nullptr)
 	{
-		bool hold_controller_holding = _app->GetInputDigital(_app->_input_handles.grab, _holding_controller->InputHandle()).bState;
+		bool hold_controller_holding = _app->GetInputDigital(_app->_input_handles.edit.grab, _holding_controller->InputHandle()).bState;
 		if (_resize_controller != nullptr)
 		{
-			bool resize_controller_holding = _app->GetInputDigital(_app->_input_handles.grab, _resize_controller->InputHandle()).bState;
+			bool resize_controller_holding = _app->GetInputDigital(_app->_input_handles.edit.grab, _resize_controller->InputHandle()).bState;
 			if (!resize_controller_holding)
 			{
 				_resize_controller = nullptr;

src/overlay.h

@@ -43,6 +43,8 @@ class Overlay
 	void SetRatio(float ratio);
 	void SetTexture(vr::Texture_t *texture);
 	void SetTextureToColor(uint8_t r, uint8_t g, uint8_t b);
+	void SetColor(float r, float g, float b);
+	void SetColor(Color c);
 
 	glm::mat4x4 GetTransformAbsolute();
 	Target *GetTarget();

src/panel.cpp

@@ -24,6 +24,18 @@ Panel::Panel(App *app, int index, int x, int y, int width, int height)
 	_texture.handle = (void *)(uintptr_t)_gl_texture;
 	_overlay.SetRatio(height / (float)width);
 	_overlay.SetTextureToColor(50, 20, 50);
+	ResetTransform();
+}
+
+void Panel::ResetTransform()
+{
+	float width = _width / _app->_pixels_per_meter;
+	float pos_x = _x / _app->_pixels_per_meter + width / 2.0f - _app->_total_width_meters / 2.0f;
+	float height = _height / _app->_pixels_per_meter;
+	float pos_y = 1.2f + _y / _app->_pixels_per_meter - height / 2.0f + _app->_total_height_meters / 2.0f;
+	VRMat pose = {{{1, 0, 0, pos_x}, {0, 1, 0, pos_y}, {0, 0, 1, 0}}};
+	_overlay.SetTransformWorld(&pose);
+	_overlay.SetWidth(width);
 }
 
 void Panel::Update()
@@ -56,6 +68,18 @@ void Panel::SetHidden(bool state)
 	_overlay.SetHidden(state);
 }
 
+Ray Panel::IntersectRay(glm::vec3 origin, glm::vec3 direction, float max_len)
+{
+	auto ray = _overlay.IntersectRay(origin, direction, max_len);
+	ray.hit_panel = this;
+	return ray;
+}
+
+void Panel::SetCursor(int x, int y)
+{
+	_app->SetCursor(x + _x, y + _y);
+}
+
 void Panel::UpdateCursor()
 {
 	auto global_pos = _app->GetCursorPosition();

src/panel.h

@@ -17,6 +17,20 @@ class Panel
 
 	void Update();
 	void SetHidden(bool state);
+	void ResetTransform();
+
+	int Width()
+	{
+		return _width;
+	}
+	int Height()
+	{
+		return _height;
+	}
+
+	void SetCursor(int x, int y);
+
+	Ray IntersectRay(glm::vec3 origin, glm::vec3 direction, float max_len);
 
 	Overlay *GetOverlay();
 

src/util.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "../openvr/openvr.h"
+#include "../lib/openvr.h"
 #include <glm/glm.hpp>
 
 typedef vr::TrackedDeviceIndex_t TrackerID;
@@ -11,10 +11,20 @@ const VRMat VRMatIdentity{{{1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 1, 0}}};
 const int MAX_TRACKERS = vr::k_unMaxTrackedDeviceCount;
 
 class Overlay;
+class Panel;
 struct Ray
 {
 	Overlay *overlay;
 	float distance;
+	glm::vec3 local_pos;
+	Panel *hit_panel;
+};
+
+struct Color
+{
+	float r;
+	float g;
+	float b;
 };
 
 inline void PrintVec(glm::vec3 v)