izzy/UnrealEngineUWP
0
0
Fork 0
mirror of https://github.com/izzy2lost/UnrealEngineUWP.git synced 2026-03-26 18:15:20 -07:00
Code Issues Packages Projects Releases Wiki Activity

- Updated to Oculus mobile SDK 0.5.0

Browse Source 
- Removed 0.4.2

Code changes to the SDK:
- Disabled ES3 in the capture code.
- Commented out JNI_OnLoad since we statically link the lib.

[CL 2511091 by JJ Hoesing in Main branch]
This commit is contained in:
JJ Hoesing
2015-04-13 20:15:01 -04:00
committed by JJ.Hoesing@epicgames.com
parent ac318d35be
commit 010b674020
476 changed files with 43460 additions and 16506 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
Engine/Build/Android/Java/libs/vrlib.jar
View File

Binary file not shown.

80
Engine/Build/Commit.gitdeps.xml
View File

@@ -16717,28 +16717,21 @@
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRAudio/LibOVRAudio/lib/win64/ovraudio.link64.lib" Hash="8ba91cd515d26b512ebeb1eafaba74153351e8d8" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/lib/armv7/libjpeg.a" Hash="3e73aca1668ed4200393afd4da7fca71e99d8439" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/lib/armv7/liboculus.a" Hash="2d0d5fcd55663032021204b1a445d704360daf88" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/res/raw/airplane_mode.tga" Hash="fc030e90afcf43a9fafcd4a684affb75aceb0ec8" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/res/raw/battery_fill.tga" Hash="dd5312c1f7820e8caf78411007eddc061235f3ec" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/res/raw/battery_indicator.tga" Hash="ec76cda821f9523e3b6dffee435c924359e07dd4" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/res/raw/color_ramp_battery.tga" Hash="f56071e5679458e786606835cf30a3eb411fc2e5" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/res/raw/color_ramp_timer.tga" Hash="887b79ce7e2c4e91d2d37fe46f6b3b54ab066c21" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/res/raw/gaze_cursor.tga" Hash="8a21a28591c77dae808fa3e47101e7fbc1e63f53" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/res/raw/gaze_cursor_cross.tga" Hash="642b4ce81e6f113960b0fff0c604262c09887aa0" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/res/raw/gaze_cursor_cross_hi.tga" Hash="83ed37d0ce525aaf66b98d9533aab9c17dcf7443" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/res/raw/gaze_cursor_dot.tga" Hash="74522aa3f43549759feb8809347e45aa6c959052" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/res/raw/gaze_cursor_dot_hi.tga" Hash="7b9cf911516bf93d789896151d36066d95288efa" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/res/raw/gaze_cursor_hand.tga" Hash="d3fcdcf14df97ac645ecf0d44539de80214c86ee" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/res/raw/gaze_cursor_hi.tga" Hash="8b686a94b5730f55f647cb0c16ad87fed2912c15" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/res/raw/gaze_cursor_timer.tga" Hash="989547647339be833a59702260661f85da7de5b5" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/res/raw/globalmenu_floor_plane.tga" Hash="295ddb7ae44869e069b049aaaa68b07489dd1ea0" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/res/raw/panel.tga" Hash="6e11db088062a49ea11529e124051444a9b9fd9d" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/res/raw/panel_hi.tga" Hash="d4620f4f48fed420b32097547a37e7b9fbbf198e" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/res/raw/panel_hi_square.tga" Hash="db351c856d4853f8bbdbd340fda402ef0eadceb0" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/res/raw/panel_square.tga" Hash="8a0f07c02586b51dbde938f2621c59b16566a078" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/res/raw/slider_bar.tga" Hash="d5ca94efdc28a776cfb9646882d86bcb6619d913" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/res/raw/slider_caret.tga" Hash="f13a78ef91db2d447d32c68566311638a30753b7" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/res/raw/slider_caret_hi.tga" Hash="6b79ba227aecad1c2dfbc79f0fc19343dfac61af" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/res/raw/ui_panel_test_256x64.tga" Hash="36740d69c6ae9b1946bb339d69097d53979f5cda" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_050/lib/armv7/liboculus.a" Hash="92defe4cb9f80dcd479892aa36fc6b23715764bf" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_050/VRLib/res/raw/color_ramp_timer.tga" Hash="887b79ce7e2c4e91d2d37fe46f6b3b54ab066c21" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_050/VRLib/res/raw/gaze_cursor.tga" Hash="8a21a28591c77dae808fa3e47101e7fbc1e63f53" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_050/VRLib/res/raw/gaze_cursor_cross.tga" Hash="642b4ce81e6f113960b0fff0c604262c09887aa0" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_050/VRLib/res/raw/gaze_cursor_cross_hi.tga" Hash="83ed37d0ce525aaf66b98d9533aab9c17dcf7443" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_050/VRLib/res/raw/gaze_cursor_dot.tga" Hash="74522aa3f43549759feb8809347e45aa6c959052" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_050/VRLib/res/raw/gaze_cursor_dot_hi.tga" Hash="7b9cf911516bf93d789896151d36066d95288efa" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_050/VRLib/res/raw/gaze_cursor_hand.tga" Hash="d3fcdcf14df97ac645ecf0d44539de80214c86ee" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_050/VRLib/res/raw/gaze_cursor_hi.tga" Hash="8b686a94b5730f55f647cb0c16ad87fed2912c15" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_050/VRLib/res/raw/gaze_cursor_timer.tga" Hash="11274b4332690bb637e23ffefe74e9a65d81c466" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_050/VRLib/res/raw/panel.tga" Hash="b374578c32a538247270115ec2c9a70ada42e866" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_050/VRLib/res/raw/panel_hi.tga" Hash="d4620f4f48fed420b32097547a37e7b9fbbf198e" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_050/VRLib/res/raw/panel_hi_square.tga" Hash="db351c856d4853f8bbdbd340fda402ef0eadceb0" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_050/VRLib/res/raw/panel_square.tga" Hash="8a0f07c02586b51dbde938f2621c59b16566a078" />
<File Name="Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_050/VRLib/res/raw/ui_panel_test_256x64.tga" Hash="36740d69c6ae9b1946bb339d69097d53979f5cda" />
<File Name="Engine/Source/ThirdParty/Ogg/libogg-1.2.2/lib/Android/ARMv7/libogg.a" Hash="52961c138f84aa64dc64c981e028616c93f651c1" />
<File Name="Engine/Source/ThirdParty/Ogg/libogg-1.2.2/lib/Android/x64/libogg.a" Hash="1b3d8a7fa7df4136d28680e5058d0d5c5b511f38" />
<File Name="Engine/Source/ThirdParty/Ogg/libogg-1.2.2/lib/Android/x86/libogg.a" Hash="8d9a8c7ad0f38ad60a7ea02ae2a1f58adb7f8be4" />
@@ -19922,6 +19915,7 @@
<Blob Hash="11221f5780f73109d06748c12da0f7b00ce5c4e6" Size="3419" PackHash="5e7d96af5e5b1cafa670bd77ae918457a118f7a5" PackOffset="632511" />
<Blob Hash="11231bd5076b7e8d493a0508dfd4dfffaf21c995" Size="24412" PackHash="5e4cff06c76c2e8a3bc9e0b4d0633323643189e6" PackOffset="1150682" />
<Blob Hash="1124f937e277e29bac55a68b06b58a3268a4bba7" Size="2000912" PackHash="1ca9d18602e87bfc51e3987f1d124cafdf353622" PackOffset="8" />
<Blob Hash="11274b4332690bb637e23ffefe74e9a65d81c466" Size="262188" PackHash="d35e0e3be355000f20587f451a57103efbe61016" PackOffset="631042" />
<Blob Hash="113598c7792f4bd15fdc9ccd28980ee4615b70c5" Size="43738" PackHash="b92e5fccb5add9213fa3b139f916c4f097445ebd" PackOffset="2046618" />
<Blob Hash="113687e25ec8ff16b8214c3534bc372941df825c" Size="8838906" PackHash="fa3c3cf43525a5cf7e63f9b4de6d7441a0e826af" PackOffset="8" />
<Blob Hash="1136bba0636ae8a71f328374937722240aa00445" Size="93111" PackHash="8a56fbe6d0dec5b3c2305bd4e775cca3889b2d44" PackOffset="1224529" />
@@ -21042,7 +21036,6 @@
<Blob Hash="295802889ae6275341f60e9af62699d2f8947154" Size="120054" PackHash="02f911003167be7b08c3fbf9bdababa124958f48" PackOffset="1128730" />
<Blob Hash="295a1b1cbe23949f1a784f21dbed97d84d9cfb7a" Size="201" PackHash="c96e9cd94a86b222bed132142b65c1d90314445d" PackOffset="1101554" />
<Blob Hash="295ac77c2131a2871216179e26694f4380467454" Size="285854" PackHash="235cc68a11ea8011ea5ca0d1326a488fd48ee713" PackOffset="1260360" />
<Blob Hash="295ddb7ae44869e069b049aaaa68b07489dd1ea0" Size="1048620" PackHash="d08b402c72c6a474440307971bacfb2663f49033" PackOffset="8" />
<Blob Hash="295ff34e788590145385a4cb4ba26e5775544afc" Size="2733" PackHash="02f911003167be7b08c3fbf9bdababa124958f48" PackOffset="843707" />
<Blob Hash="29610742a3e0cc221a5e68f4e5edf603a6881046" Size="7016" PackHash="01d26cddb178f064c3cd74a09430970bf6cc12b7" PackOffset="827532" />
<Blob Hash="29612f275fb8b83da19407fd12c7eae96fe11702" Size="100717" PackHash="af412e3bcac064293cc367941ad02eddcc3e5a44" PackOffset="1088704" />
@@ -21632,7 +21625,7 @@
<Blob Hash="3657c25c0140f4b00dd7dfc850fffb646432f305" Size="4391" PackHash="d7cd467675e181dbeba3cf24443590ebb76f9515" PackOffset="2050098" />
<Blob Hash="3669a6f65c605d7480808cd64e6b38fa64b08b8f" Size="5311" PackHash="d7cd467675e181dbeba3cf24443590ebb76f9515" PackOffset="709924" />
<Blob Hash="366c93fcafaee957a53afe1bfe84200da92053f2" Size="2721245" PackHash="09007b1cd8b9f90a5ab85549323903759f18b852" PackOffset="8" />
<Blob Hash="36740d69c6ae9b1946bb339d69097d53979f5cda" Size="65580" PackHash="d08b402c72c6a474440307971bacfb2663f49033" PackOffset="1769700" />
<Blob Hash="36740d69c6ae9b1946bb339d69097d53979f5cda" Size="65580" PackHash="d35e0e3be355000f20587f451a57103efbe61016" PackOffset="1745374" />
<Blob Hash="36820313c132e007a0a974857bab92f9be664fdd" Size="454" PackHash="0f74ff9d91cbb2b2061d50909d5d7f093b845a72" PackOffset="2093599" />
<Blob Hash="36820ecf0b0e91aeaf5ef35ac3a40073e50f522d" Size="5465" PackHash="289a1b921105ce48ba09d95a245cd2daa77b05bb" PackOffset="289660" />
<Blob Hash="368597b1fbcd5b86d2bb4efee3eb9c26370ea1c9" Size="9296" PackHash="bad3d27e656261f89d7bfe9409032b1623077a17" PackOffset="1248662" />
@@ -23882,7 +23875,7 @@
<Blob Hash="64213f27b586680ecd96dd96fe53cb244648b138" Size="6416" PackHash="1d09bb4f8ba502cef13de6d570839e6790bf3542" PackOffset="142424" />
<Blob Hash="6423e6b4b6229b03867e0f8d7832e2af44097753" Size="1052" PackHash="2f143d8520d94bbf2cb250b35a8f79e3d3e8572c" PackOffset="1146988" />
<Blob Hash="64294ce6ffc806d8440fc369af2d12887f42a7da" Size="6070" PackHash="d92734f6a18a11d0dfbf8c9e12f63f2180c5225d" PackOffset="316377" />
<Blob Hash="642b4ce81e6f113960b0fff0c604262c09887aa0" Size="16428" PackHash="46bf47de45f52b05654a92f7623f345bdf075c0d" PackOffset="455423" />
<Blob Hash="642b4ce81e6f113960b0fff0c604262c09887aa0" Size="16428" PackHash="d35e0e3be355000f20587f451a57103efbe61016" PackOffset="382543" />
<Blob Hash="643df16c168037e3d173af653743832f37e977b4" Size="8170" PackHash="fc9d37a2c0ab6854c6b039c509d86b9459982472" PackOffset="2056370" />
<Blob Hash="6447148ceddccd41c197a9fb96a21d801f8e69b9" Size="25037" PackHash="32677db50adec76bbba51613b8987a7c7e82be9d" PackOffset="767659" />
<Blob Hash="64476e69926496469ab398fa7b204feca7e57be5" Size="972" PackHash="33d0a2949662b327b35a881192e85107ecafc8ac" PackOffset="518716" />
@@ -24243,7 +24236,6 @@
<Blob Hash="6b770b40b189043526a0a8123a57a291cbca0034" Size="5661" PackHash="d92734f6a18a11d0dfbf8c9e12f63f2180c5225d" PackOffset="1943901" />
<Blob Hash="6b770f5f96e7a077e603b1ebf22d871dd276031a" Size="3187" PackHash="5dbebfe34ab5c28eca7d7b6c57ff41cda029cf64" PackOffset="1147576" />
<Blob Hash="6b7777e08d8f6f4a98336dda2b0c5a55c86e8c2b" Size="3183" PackHash="32677db50adec76bbba51613b8987a7c7e82be9d" PackOffset="1748653" />
<Blob Hash="6b79ba227aecad1c2dfbc79f0fc19343dfac61af" Size="11708" PackHash="46bf47de45f52b05654a92f7623f345bdf075c0d" PackOffset="1131638" />
<Blob Hash="6b7b90262de494199999bd419c92e69743ba1601" Size="61989" PackHash="8db9bb91759363ec605c3d44273194136ce7dc1f" PackOffset="1559794" />
<Blob Hash="6b7d3fa098c8a3a70fb7e92bdbb0fd0a1c36bfb6" Size="321968" PackHash="cfaa6e2212f937f340e867175482030d495675ed" PackOffset="726519" />
<Blob Hash="6b83da355751b140fb7cb1b29d024230c39c0d1f" Size="4384" PackHash="b3b4d366e1d90d3fbd5f3d43a93bfde43a24d158" PackOffset="171699" />
@@ -24362,7 +24354,6 @@
<Blob Hash="6e00f373c930d22cdab24ff9e8120d77599ae075" Size="4110566" PackHash="abcd992f6c90c47b9150148778b5e5dd0be366f5" PackOffset="8" />
<Blob Hash="6e04d552313dd4004b5e53f823bc30979e25b949" Size="37357" PackHash="0255260ee4d81de161e877cdcc3af4d7fcf8d0e3" PackOffset="1211519" />
<Blob Hash="6e0e13dc2a56f1589001d386574cb292e6b69396" Size="31532" PackHash="957337ec86f032a91c82dfc2f859843e3a1c1e88" PackOffset="609162" />
<Blob Hash="6e11db088062a49ea11529e124051444a9b9fd9d" Size="163884" PackHash="46bf47de45f52b05654a92f7623f345bdf075c0d" PackOffset="966110" />
<Blob Hash="6e19d212416a1ce3ab2749649b93f500ecb63f6c" Size="4913" PackHash="5e7d96af5e5b1cafa670bd77ae918457a118f7a5" PackOffset="1221247" />
<Blob Hash="6e1a199643b40792f2b2854723d01790b37f1692" Size="2825" PackHash="0255260ee4d81de161e877cdcc3af4d7fcf8d0e3" PackOffset="269386" />
<Blob Hash="6e21645cafb3f2705fa357783e520249ce49e136" Size="3178" PackHash="12d213957fbfe643a97d5072b1f6ae30aeebcbb7" PackOffset="95422" />
@@ -24667,7 +24658,7 @@
<Blob Hash="744921b64985baa9fb3987044afbd99b236a49d2" Size="3157" PackHash="fc72803a9439e161de25108be11e5429ed900f77" PackOffset="846968" />
<Blob Hash="744bc2457ab58e7274ec85d4a33e5cab3a4ef3d4" Size="1662012" PackHash="c7d451a7ac00e4726f44c4fb551c45dfd4614302" PackOffset="8" />
<Blob Hash="744d3ee9397084646c81e5c70d8458707aec31b9" Size="2912" PackHash="f4f360f81e0fe0c3b19ba2e927c0edf2ca16dd74" PackOffset="911815" />
<Blob Hash="74522aa3f43549759feb8809347e45aa6c959052" Size="65580" PackHash="46bf47de45f52b05654a92f7623f345bdf075c0d" PackOffset="488279" />
<Blob Hash="74522aa3f43549759feb8809347e45aa6c959052" Size="65580" PackHash="d35e0e3be355000f20587f451a57103efbe61016" PackOffset="415399" />
<Blob Hash="745381f07a0370853f003814c35b958f13bb2649" Size="683466" PackHash="02846027825bd3d2c10152a1e20dc70b9084b3f6" PackOffset="765775" />
<Blob Hash="74580bc5fc5d2da48eecbff81ae2387642f95c4e" Size="62676" PackHash="a9c62ffacb1508452705b057c5f796573d47c78d" PackOffset="2931" />
<Blob Hash="7460c394a5c9752ac9ca6c038f6ffc8cb891cca6" Size="84" PackHash="1d09bb4f8ba502cef13de6d570839e6790bf3542" PackOffset="2084464" />
@@ -25023,7 +25014,7 @@
<Blob Hash="7b9452f224a77263f3f072f5e1c6a9b422ba5ebe" Size="3648" PackHash="4905bf362dac5be04631d1ce552b8184a6f9eb7f" PackOffset="633496" />
<Blob Hash="7b94988d209305f62b4d34aa75b19803ca4e55c7" Size="5386" PackHash="d92734f6a18a11d0dfbf8c9e12f63f2180c5225d" PackOffset="2034168" />
<Blob Hash="7b99efdec12e65005e90f87a4978c4f88d94908d" Size="2154620" PackHash="cdd688702f443bffa2489a96724ed42ba260d39e" PackOffset="8" />
<Blob Hash="7b9cf911516bf93d789896151d36066d95288efa" Size="65580" PackHash="46bf47de45f52b05654a92f7623f345bdf075c0d" PackOffset="553859" />
<Blob Hash="7b9cf911516bf93d789896151d36066d95288efa" Size="65580" PackHash="d35e0e3be355000f20587f451a57103efbe61016" PackOffset="480979" />
<Blob Hash="7b9dc8af9301ad63eb3804b9bd1f5dc03e8b0b82" Size="18713" PackHash="fe79883294e7b730b4ea0e6e72c662ced28e999b" PackOffset="696560" />
<Blob Hash="7ba0038a5d125b13077befbd63cd4644254b9260" Size="5396" PackHash="c96e9cd94a86b222bed132142b65c1d90314445d" PackOffset="140165" />
<Blob Hash="7ba1634d7782fecced68542cc795dcd4a5fdaef7" Size="4264" PackHash="f4f360f81e0fe0c3b19ba2e927c0edf2ca16dd74" PackOffset="852960" />
@@ -25458,7 +25449,7 @@
<Blob Hash="83e624294da776f0ceb3aadd9982e4110cea7351" Size="9016" PackHash="33d0a2949662b327b35a881192e85107ecafc8ac" PackOffset="1643948" />
<Blob Hash="83e769afb908f92ec49f8246630a7bb5722b8d7b" Size="6062" PackHash="836ee88c57cc1b5617f36a2b9fb19db420285b69" PackOffset="2090802" />
<Blob Hash="83ece64f2a6655aecea047f77a28a1a5313e2784" Size="11264" PackHash="b8e153475935a408d91ca55c8e98030d5cc99ceb" PackOffset="329736" />
<Blob Hash="83ed37d0ce525aaf66b98d9533aab9c17dcf7443" Size="16428" PackHash="46bf47de45f52b05654a92f7623f345bdf075c0d" PackOffset="471851" />
<Blob Hash="83ed37d0ce525aaf66b98d9533aab9c17dcf7443" Size="16428" PackHash="d35e0e3be355000f20587f451a57103efbe61016" PackOffset="398971" />
<Blob Hash="83ed4488de197fc63a24e0d386a0332fbf97d645" Size="35572" PackHash="7c963542515f21d8db5b961bee100b6412d597d1" PackOffset="147555" />
<Blob Hash="83f31e9fe24728b3455a976a482c201236f56053" Size="89614" PackHash="fc71358f88c1a01c32f496b064386dba3145a36a" PackOffset="1896636" />
<Blob Hash="83f5a03fa2ca5f3b520ac5ced51af9df0aec9ce1" Size="17017" PackHash="c9b2fa52f0b68b4de48806e71af562ddd9ab8363" PackOffset="565048" />
@@ -25671,7 +25662,7 @@
<Blob Hash="88525f6fd380eb9f27df101c5091fdf0f7a0622b" Size="4111" PackHash="87925181e3a8b737757401a6114a8acf82625a49" PackOffset="1355098" />
<Blob Hash="88685414514a013e774aa28c34cab0737062474b" Size="232" PackHash="12d213957fbfe643a97d5072b1f6ae30aeebcbb7" PackOffset="677973" />
<Blob Hash="88744f2be2e8323e0215c6211189fa269e16a87b" Size="1120044" PackHash="458b125e9303946026ae1d01ec88473625a5d817" PackOffset="8" />
<Blob Hash="887b79ce7e2c4e91d2d37fe46f6b3b54ab066c21" Size="262188" PackHash="46bf47de45f52b05654a92f7623f345bdf075c0d" PackOffset="176807" />
<Blob Hash="887b79ce7e2c4e91d2d37fe46f6b3b54ab066c21" Size="262188" PackHash="d35e0e3be355000f20587f451a57103efbe61016" PackOffset="103927" />
<Blob Hash="888366531caff7b7d1bccb43aa7eb804945043d0" Size="2944" PackHash="16e421c9204b08586edd8de93b93b19fb10644ea" PackOffset="999632" />
<Blob Hash="888a9b64da86c6565328f4a3e6f8ceda925e7732" Size="5156" PackHash="33d0a2949662b327b35a881192e85107ecafc8ac" PackOffset="1358152" />
<Blob Hash="888f0eecad19af59bb88c7d9008d2f63e52301ed" Size="2950" PackHash="f4f360f81e0fe0c3b19ba2e927c0edf2ca16dd74" PackOffset="1288027" />
@@ -25746,10 +25737,10 @@
<Blob Hash="89f3c079cf4dc9697fbae93ea4b8e48b2f86d0dd" Size="136" PackHash="16e421c9204b08586edd8de93b93b19fb10644ea" PackOffset="1801760" />
<Blob Hash="8a0511e523e37bdbd82e5ceb421a9063a7c79d09" Size="146220" PackHash="f988fe286fc9c37eb7e5e8903d7647ee76b89e2b" PackOffset="1777097" />
<Blob Hash="8a07bda2c76757818ada686c86949a665b902de1" Size="18856" PackHash="bad3d27e656261f89d7bfe9409032b1623077a17" PackOffset="1082046" />
<Blob Hash="8a0f07c02586b51dbde938f2621c59b16566a078" Size="262188" PackHash="d08b402c72c6a474440307971bacfb2663f49033" PackOffset="1474700" />
<Blob Hash="8a0f07c02586b51dbde938f2621c59b16566a078" Size="262188" PackHash="d35e0e3be355000f20587f451a57103efbe61016" PackOffset="1483186" />
<Blob Hash="8a140c688b59b70167d430a543514a4897a9d9c4" Size="18244" PackHash="12d213957fbfe643a97d5072b1f6ae30aeebcbb7" PackOffset="299830" />
<Blob Hash="8a1f411f166d127ce508fa9e2e56c326e7e52c17" Size="15253998" PackHash="d98694dcd712bd952b620d7cab0181941986982d" PackOffset="8" />
<Blob Hash="8a21a28591c77dae808fa3e47101e7fbc1e63f53" Size="16428" PackHash="46bf47de45f52b05654a92f7623f345bdf075c0d" PackOffset="438995" />
<Blob Hash="8a21a28591c77dae808fa3e47101e7fbc1e63f53" Size="16428" PackHash="d35e0e3be355000f20587f451a57103efbe61016" PackOffset="366115" />
<Blob Hash="8a230030219732420da68049ffa3e161e6ac6bb7" Size="208" PackHash="2f143d8520d94bbf2cb250b35a8f79e3d3e8572c" PackOffset="1146780" />
<Blob Hash="8a23b4a7acfa83684027cd4747640e84d01c7b86" Size="18552" PackHash="16e421c9204b08586edd8de93b93b19fb10644ea" PackOffset="930008" />
<Blob Hash="8a252f98754144adf98f47941a34bae4a10ec071" Size="418" PackHash="469f682fe29e603c3aa8f35dc7a32faea5ab5c09" PackOffset="1916332" />
@@ -25820,7 +25811,7 @@
<Blob Hash="8b5efe4f4ac547f879c1f69ab974a95f3936b948" Size="7457" PackHash="3c6fd2f94e3497924851a5d8254666518d47a633" PackOffset="2004065" />
<Blob Hash="8b5fe104d4a8307845c372d2890e1b29b2527d13" Size="205664" PackHash="4d6f9c6d7a261e35898225b1fade32da175cb530" PackOffset="1594810" />
<Blob Hash="8b681aee313158a94ad9e2352aee9c7be640368f" Size="10240" PackHash="7e6ab4f547b9d8bf5f8a35a74d335d500588d8d9" PackOffset="481800" />
<Blob Hash="8b686a94b5730f55f647cb0c16ad87fed2912c15" Size="16428" PackHash="46bf47de45f52b05654a92f7623f345bdf075c0d" PackOffset="687494" />
<Blob Hash="8b686a94b5730f55f647cb0c16ad87fed2912c15" Size="16428" PackHash="d35e0e3be355000f20587f451a57103efbe61016" PackOffset="614614" />
<Blob Hash="8b6916d9e2475a72a5a9318fb5a37d97682a8393" Size="36936" PackHash="62e18e2b34d9ca5872cacacfd6eb9e94afd0eb2e" PackOffset="322378" />
<Blob Hash="8b6a6fc1e00a3ee8ee3d865bf3a9661eba2dab85" Size="35706" PackHash="32677db50adec76bbba51613b8987a7c7e82be9d" PackOffset="557955" />
<Blob Hash="8b6bc21fb712d799c203067536aa4366357678fc" Size="3339" PackHash="fc72803a9439e161de25108be11e5429ed900f77" PackOffset="339570" />
@@ -26176,6 +26167,7 @@
<Blob Hash="92d43348cd13210263ef1f859c540af4a97553b7" Size="2929" PackHash="4905bf362dac5be04631d1ce552b8184a6f9eb7f" PackOffset="673070" />
<Blob Hash="92d4b0b199d14488bcb0916a3367b35903087213" Size="71152" PackHash="1aad9a745382e917c890acd98a988a1536087fe2" PackOffset="1974104" />
<Blob Hash="92d90c65d52c9a022ff903661487aa8d4ae46b21" Size="40200" PackHash="d25faf54b177d399192ede835440a8eb4948ab59" PackOffset="1647553" />
<Blob Hash="92defe4cb9f80dcd479892aa36fc6b23715764bf" Size="20689570" PackHash="fe9eb395a4b20285ccad1eeebc882089b33ab889" PackOffset="8" />
<Blob Hash="92e674bc6cdd87b6dc0faaeaa834708b893e1e36" Size="65339" PackHash="1679ff7ab2527671a6c79835501cd4447f769d26" PackOffset="1984620" />
<Blob Hash="92e82b51cd9937b35a019e47d83f4c9528ed1a90" Size="85504" PackHash="7e6ab4f547b9d8bf5f8a35a74d335d500588d8d9" PackOffset="8" />
<Blob Hash="92f5438c642618e2d5825c64b7f453136ff2579f" Size="73264" PackHash="afb9d2946f9c3633fb9df0e2acc0f5a2cb5a7753" PackOffset="1930241" />
@@ -26451,7 +26443,6 @@
<Blob Hash="988ccb0a4711e62a3c99e44f6dfb86a7067ef5bd" Size="1051484" PackHash="434a686e8b55bbed590d5f66f4c2d914e3cff5c6" PackOffset="8" />
<Blob Hash="9891568a270cfd3afb87df11932e5de2b8cb7f98" Size="30524" PackHash="4b6a1631906e490aad98097955aaed303b835e4c" PackOffset="1071429" />
<Blob Hash="9893b81846498e67dc25c33934f5e536371fc930" Size="2920" PackHash="cb73a430e097bac42d93ec902203b7888ed0b681" PackOffset="645666" />
<Blob Hash="989547647339be833a59702260661f85da7de5b5" Size="262188" PackHash="46bf47de45f52b05654a92f7623f345bdf075c0d" PackOffset="703922" />
<Blob Hash="98955d226bff7fb5581c52cff5e71a6474bd5eaa" Size="2954" PackHash="e458507f455e3bac9232d632426fc4b75f29841d" PackOffset="95578" />
<Blob Hash="989adbdbcbb542198a3249d99af2b1ab816d2520" Size="9229" PackHash="ebcdbd3113ce1b1b12aba710b9ed475f2b77bf74" PackOffset="1848485" />
<Blob Hash="98a16cc50cf0d25cbac315f4c03151f1f0e41029" Size="2647" PackHash="5a4c5b85fb81b291e8fb6f7c37c0b152f8aeb1bb" PackOffset="2034918" />
@@ -27726,6 +27717,7 @@
<Blob Hash="b366ab848bb85ac6789026c7c980d46e567dc01e" Size="6505" PackHash="957337ec86f032a91c82dfc2f859843e3a1c1e88" PackOffset="1184089" />
<Blob Hash="b369cd92036640195d8ca97c2b8aa6cf6407b470" Size="3578" PackHash="89550f66a2a48a9f1b9089703e9b33eb14a23ae5" PackOffset="1046692" />
<Blob Hash="b373008df754ba06a514d1c258167e3a4f51b042" Size="30056" PackHash="bad3d27e656261f89d7bfe9409032b1623077a17" PackOffset="561201" />
<Blob Hash="b374578c32a538247270115ec2c9a70ada42e866" Size="163884" PackHash="d35e0e3be355000f20587f451a57103efbe61016" PackOffset="893230" />
<Blob Hash="b374cc5c7f8aa4457d6415f127762a029b964081" Size="2982" PackHash="0255260ee4d81de161e877cdcc3af4d7fcf8d0e3" PackOffset="483858" />
<Blob Hash="b3752044affaeb04f29a205349a940ea233a57f6" Size="129024" PackHash="7e6ab4f547b9d8bf5f8a35a74d335d500588d8d9" PackOffset="85512" />
<Blob Hash="b3760c1ae3eb0f82295f065fccac3d7967fac896" Size="4684" PackHash="0255260ee4d81de161e877cdcc3af4d7fcf8d0e3" PackOffset="2071333" />
@@ -29307,7 +29299,7 @@
<Blob Hash="d3f25b22c073e5834af161927708b8d216eb4d32" Size="1141690" PackHash="6d263531086a2ac8abcd381816ca4bbebeb2bb89" PackOffset="8" />
<Blob Hash="d3f60436f21429502455f1f8cdc8248c41c2267d" Size="4940" PackHash="4f9629d19fa7928aaae10e4bb7c79195fb4f2436" PackOffset="140655" />
<Blob Hash="d3f635e1fd2a7e49654435b1943a298b7befa907" Size="20062" PackHash="ebcdbd3113ce1b1b12aba710b9ed475f2b77bf74" PackOffset="1925788" />
<Blob Hash="d3fcdcf14df97ac645ecf0d44539de80214c86ee" Size="68055" PackHash="46bf47de45f52b05654a92f7623f345bdf075c0d" PackOffset="619439" />
<Blob Hash="d3fcdcf14df97ac645ecf0d44539de80214c86ee" Size="68055" PackHash="d35e0e3be355000f20587f451a57103efbe61016" PackOffset="546559" />
<Blob Hash="d3fec88bd288fdcca99e195e7c40813b9a1ed1b7" Size="7216" PackHash="6f9f6fde084d43534af6bcfb5cd0df39acc952c2" PackOffset="215142" />
<Blob Hash="d401a9dbe7cdd092fae750efe2c228ce7bcb4778" Size="88" PackHash="2f143d8520d94bbf2cb250b35a8f79e3d3e8572c" PackOffset="1782032" />
<Blob Hash="d403fe1956473c1373e8c2a28f7cc26a8e6e118a" Size="91040" PackHash="f78aad390fe2fc34bef952e17db85bc91b672bd7" PackOffset="2002152" />
@@ -29322,7 +29314,7 @@
<Blob Hash="d456e8e1c3cca043d84541c27d5fb08197ac768e" Size="255484" PackHash="16d572296ce2501e51962113f84536afc6df2b44" PackOffset="1794448" />
<Blob Hash="d45888e0c56bc815364fe609c78077067584cab9" Size="88" PackHash="ebcdbd3113ce1b1b12aba710b9ed475f2b77bf74" PackOffset="2097060" />
<Blob Hash="d4597aba7d6fea19dfe83379646871058530bd51" Size="2718" PackHash="02f911003167be7b08c3fbf9bdababa124958f48" PackOffset="502175" />
<Blob Hash="d4620f4f48fed420b32097547a37e7b9fbbf198e" Size="163884" PackHash="d08b402c72c6a474440307971bacfb2663f49033" PackOffset="1048628" />
<Blob Hash="d4620f4f48fed420b32097547a37e7b9fbbf198e" Size="163884" PackHash="d35e0e3be355000f20587f451a57103efbe61016" PackOffset="1057114" />
<Blob Hash="d46aa63f8a5e0acc37637df3702c954f0bdd5b7b" Size="10096" PackHash="2f143d8520d94bbf2cb250b35a8f79e3d3e8572c" PackOffset="2050412" />
<Blob Hash="d482226aabb83cf9c3f7db7ea7ad260ce85d4c90" Size="5743" PackHash="c737649a3efb2ce8f5a46fe18a46a21cf6aca47b" PackOffset="898128" />
<Blob Hash="d489d945ad701ccc0b0d1fd5a651420d28872e89" Size="1964848" PackHash="85b191ae1844ad6da93fa57876c8850de342b4ca" PackOffset="8" />
@@ -29397,7 +29389,6 @@
<Blob Hash="d5b737b43e3d5043f11681b1f925ab3b5dfbc29d" Size="3873232" PackHash="a6dab2c94b45a31a90fb089abdcde2ea3a9343dd" PackOffset="8" />
<Blob Hash="d5ba66cb306c72049e0c2a1aa4df09000f2d03cd" Size="88" PackHash="33d0a2949662b327b35a881192e85107ecafc8ac" PackOffset="757684" />
<Blob Hash="d5c2b47a77dc56575f1451eccef25fd56cb2a940" Size="62151" PackHash="61edd2f04c73c5c3eca0bfae13c92213516504e3" PackOffset="2026909" />
<Blob Hash="d5ca94efdc28a776cfb9646882d86bcb6619d913" Size="32812" PackHash="d08b402c72c6a474440307971bacfb2663f49033" PackOffset="1736888" />
<Blob Hash="d5cb8493004e69bab6aaba74bfe8fe22f3f19386" Size="212" PackHash="2cdd470456c37254f413bef8259872fb2f331329" PackOffset="2089078" />
<Blob Hash="d5cc51cb66a3bfa1951dad73b84b4ebcfac0b903" Size="100" PackHash="2f143d8520d94bbf2cb250b35a8f79e3d3e8572c" PackOffset="775588" />
<Blob Hash="d5ccec7b27ab58ea2557c47e77929e8084a48fd4" Size="4320" PackHash="872d8425ff2c03795588c5ed43bafb772f6d9053" PackOffset="2091028" />
@@ -29648,7 +29639,7 @@
<Blob Hash="db268c8f0e05cbe398a4387983baca5f7a2a2845" Size="268421" PackHash="63ceab8331229d4e03c85aa9b5f4671eda2643f1" PackOffset="1808147" />
<Blob Hash="db26b0e1e651e9deb0740e8b721d67402b812180" Size="476" PackHash="4b6787230985305ec7ccf065a9fa470d6ac4f026" PackOffset="1986777" />
<Blob Hash="db2df7da2b9bdc7352b20b08eb655f302fa06950" Size="195024" PackHash="d1cc40fc311b1fe882b059047a6c7f53925c9827" PackOffset="8" />
<Blob Hash="db351c856d4853f8bbdbd340fda402ef0eadceb0" Size="262188" PackHash="d08b402c72c6a474440307971bacfb2663f49033" PackOffset="1212512" />
<Blob Hash="db351c856d4853f8bbdbd340fda402ef0eadceb0" Size="262188" PackHash="d35e0e3be355000f20587f451a57103efbe61016" PackOffset="1220998" />
<Blob Hash="db39c49f7bc2e7dfde03b4bdfd59acd3efc0a0a9" Size="30208" PackHash="da353191c48ff483572ff0951d3a22e6c3caa0fe" PackOffset="723224" />
<Blob Hash="db456e0481680c9e2d9410a7555e76fe59c9d63d" Size="2960" PackHash="33d0a2949662b327b35a881192e85107ecafc8ac" PackOffset="1059740" />
<Blob Hash="db4b640cdd3757100e6c82916120d010cb126df0" Size="3785" PackHash="eb1d2ae6891345f8e1945ab159cf7347aaff7431" PackOffset="1863901" />
@@ -29758,7 +29749,6 @@
<Blob Hash="dd3ee27f8a1963e9a8e0cbbc82792246474b65bc" Size="3309" PackHash="fe94f39680410922eeef278b013e20b5ee27e7fe" PackOffset="1880437" />
<Blob Hash="dd45903edadfe1987879abdc7e69f8d4909ee398" Size="1256" PackHash="bad3d27e656261f89d7bfe9409032b1623077a17" PackOffset="2092323" />
<Blob Hash="dd4e7a92f6978d76df51424392d7c8d12131057d" Size="72505" PackHash="de38fa1f4e72f59a4ecd2a8188b7aaa6cebc091d" PackOffset="586012" />
<Blob Hash="dd5312c1f7820e8caf78411007eddc061235f3ec" Size="1580" PackHash="46bf47de45f52b05654a92f7623f345bdf075c0d" PackOffset="108067" />
<Blob Hash="dd54614ac4348a8d00de63eb50057da1902bafff" Size="3848" PackHash="d25faf54b177d399192ede835440a8eb4948ab59" PackOffset="1159424" />
<Blob Hash="dd585d363472a5db1f42b14a381e9377ed16bcd9" Size="37331" PackHash="9bfa76eaf50a585e99981b54ef5628fd89b397e7" PackOffset="966440" />
<Blob Hash="dd63731df3c4332d585afd89138e9980f8b5efa2" Size="13707" PackHash="12d213957fbfe643a97d5072b1f6ae30aeebcbb7" PackOffset="1513560" />
@@ -29973,7 +29963,7 @@
<Blob Hash="e176f8813379778497a4ac839506e68a927ad279" Size="1112" PackHash="2f143d8520d94bbf2cb250b35a8f79e3d3e8572c" PackOffset="1171772" />
<Blob Hash="e17996e10c28638028c924d25706e21c7fba664d" Size="15890" PackHash="cfc8c6e323848f57580a531e48fc4b81cdd17efd" PackOffset="1547705" />
<Blob Hash="e17af4e0b3b9818a550d1b7c550ea25b14f76edf" Size="10240" PackHash="c705af8ab47f089acd3efa03df30ad116079209c" PackOffset="2043272" />
<Blob Hash="e1848e8222f30ef1b5bc2e31289d87e9cc1e28fa" Size="103919" PackHash="46bf47de45f52b05654a92f7623f345bdf075c0d" PackOffset="8" />
<Blob Hash="e1848e8222f30ef1b5bc2e31289d87e9cc1e28fa" Size="103919" PackHash="d35e0e3be355000f20587f451a57103efbe61016" PackOffset="8" />
<Blob Hash="e18967fc0237264812b4bf023c6dd4923206ab1e" Size="5643830" PackHash="0e7c76acd194aaec33f909b5d9275a85abccd3a1" PackOffset="8" />
<Blob Hash="e18af5e059a84fd1eb7d45b8dd83d9d7a79d4fbb" Size="62555" PackHash="9a10248ffa6ef2de0ff39750b0126e7d0b1557b6" PackOffset="1882947" />
<Blob Hash="e18fdd5dd40e20036b995f1e7a5961468b95fad2" Size="2096" PackHash="81594c92fcec0b95d7d0b47ad36aef8d2605c8b8" PackOffset="52326" />
@@ -30544,7 +30534,6 @@
<Blob Hash="ec7354fadf7345e4e88c023468c21a61cfc847cc" Size="21622" PackHash="433d0faffda8341be38e7db15a328177e51bf03b" PackOffset="654192" />
<Blob Hash="ec76437931982b6f863bd378ce293357cb31dab1" Size="3106" PackHash="551654d82bdacbe12dfe0a27ff7948b6ad1894b5" PackOffset="2093618" />
<Blob Hash="ec76b27bf027179140c9f42093b88ed2d42466e7" Size="3689" PackHash="4905bf362dac5be04631d1ce552b8184a6f9eb7f" PackOffset="1982805" />
<Blob Hash="ec76cda821f9523e3b6dffee435c924359e07dd4" Size="1580" PackHash="46bf47de45f52b05654a92f7623f345bdf075c0d" PackOffset="109647" />
<Blob Hash="ec78a07a56451109d6cd7c3a833d05d718e14cf8" Size="17736" PackHash="33d0a2949662b327b35a881192e85107ecafc8ac" PackOffset="1064296" />
<Blob Hash="ec7e3558e5779aed9734a6272e4ff4c7623ee10a" Size="23103190" PackHash="196a7cd92cd85833aa987ab46cc84abad637e671" PackOffset="8" />
<Blob Hash="ec8ff5b8358c86c56551df5c382d46db75519023" Size="946" PackHash="02b79c9e934ba5d5df21ca904400f6921b0e919c" PackOffset="961666" />
@@ -30781,7 +30770,6 @@
<Blob Hash="f121a6a8b43716ec70146099a40a8439f87fe1c1" Size="192992" PackHash="267f7ab24d96a8949db4cbc89f50cb9aa755e5e7" PackOffset="1646803" />
<Blob Hash="f12b5ece7760235eea461df6dcb3f4b13c24de06" Size="1276" PackHash="2f143d8520d94bbf2cb250b35a8f79e3d3e8572c" PackOffset="1635236" />
<Blob Hash="f1305d45dc9763d98f9b9dad6262651c55837afc" Size="3423" PackHash="4f9629d19fa7928aaae10e4bb7c79195fb4f2436" PackOffset="2087426" />
<Blob Hash="f13a78ef91db2d447d32c68566311638a30753b7" Size="1644" PackHash="46bf47de45f52b05654a92f7623f345bdf075c0d" PackOffset="1129994" />
<Blob Hash="f14bd45adf190be771143ee3a51b43bad05ce7da" Size="446220" PackHash="da353191c48ff483572ff0951d3a22e6c3caa0fe" PackOffset="1391422" />
<Blob Hash="f15dfb0b4296306690a6784004661fd7de24e8e2" Size="3109" PackHash="c96e9cd94a86b222bed132142b65c1d90314445d" PackOffset="166125" />
<Blob Hash="f16173b31f3052b0ff390de7f533ecb3458aead8" Size="3118" PackHash="fc72803a9439e161de25108be11e5429ed900f77" PackOffset="692575" />
@@ -30956,7 +30944,6 @@
<Blob Hash="f528e4ca19a4b796cf6cedd5fa53d49056d0c8c6" Size="222346" PackHash="a456f0111a1d9a6fb8045d0e5e9450b7c36f9374" PackOffset="1282128" />
<Blob Hash="f55b969a6597b37bc52723dd11400e7bc98b7f9b" Size="138268" PackHash="bc3c0a1c9b96dba9aaafb26eae5ed03cad2d8ef3" PackOffset="1023683" />
<Blob Hash="f55df6f1df46173488fe98a42b52b74fbb6c933d" Size="176" PackHash="01d26cddb178f064c3cd74a09430970bf6cc12b7" PackOffset="2086176" />
<Blob Hash="f56071e5679458e786606835cf30a3eb411fc2e5" Size="65580" PackHash="46bf47de45f52b05654a92f7623f345bdf075c0d" PackOffset="111227" />
<Blob Hash="f562e33ea9e4e9a0a75cdb73bfbfeb815ca3354a" Size="115877" PackHash="f37ec1aaee0cf4f0e90232c71e067c230b228446" PackOffset="1706973" />
<Blob Hash="f563461e571b64de004e3bdc916a80b26c9a3a8a" Size="21066" PackHash="e7a4ddc64af2a43bf5c7d439244636d60a7dae07" PackOffset="750640" />
<Blob Hash="f571739234b27eebe4ce57b17155094fd484ef95" Size="15843" PackHash="a9c62ffacb1508452705b057c5f796573d47c78d" PackOffset="2020733" />
@@ -31257,7 +31244,6 @@
<Blob Hash="fbeb41994feb81436b839dd852cfa630a1c33335" Size="587" PackHash="12d213957fbfe643a97d5072b1f6ae30aeebcbb7" PackOffset="682508" />
<Blob Hash="fbeeb480cd419e4f31c15016c02394f26dd554fe" Size="37363" PackHash="1a81e6c5fd4cc760a6589fa20070d26a9cb6e53a" PackOffset="116019" />
<Blob Hash="fbef6db66ed8949a9a6d1fb79654259493fdb362" Size="3407274" PackHash="7d8494c8c129481f7cb623f087b5f7bd19a81bde" PackOffset="8" />
<Blob Hash="fc030e90afcf43a9fafcd4a684affb75aceb0ec8" Size="4140" PackHash="46bf47de45f52b05654a92f7623f345bdf075c0d" PackOffset="103927" />
<Blob Hash="fc0d61dd117f34905db9e16a492839c9c50b755e" Size="25061" PackHash="bd84ba26edcbd1df482a5953f80c55ab60cee31f" PackOffset="1995784" />
<Blob Hash="fc195ab512d50e1d07064f529eebd68b3af676c4" Size="2898" PackHash="cb73a430e097bac42d93ec902203b7888ed0b681" PackOffset="997693" />
<Blob Hash="fc19d7ca69b51f11535e5952adddc59fff204ca2" Size="3416" PackHash="f4f360f81e0fe0c3b19ba2e927c0edf2ca16dd74" PackOffset="1009208" />
@@ -31782,7 +31768,6 @@
<Pack Hash="469f682fe29e603c3aa8f35dc7a32faea5ab5c09" Size="1921463" CompressedSize="396526" RemotePath="2504924-2d2664b520884aec9a3d3b79a2dae366" />
<Pack Hash="46a1188804f8885f9de31f7fb76a5387132e5706" Size="2089906" CompressedSize="512214" RemotePath="2502955-282171643bd84e4cb54789f6768d4370" />
<Pack Hash="46b7f7c569022f7d250739f5b404c5accc946fac" Size="5576262" CompressedSize="1421526" RemotePath="2495503-7390cc25898b4ab0a4f9f846f2fd7754" />
<Pack Hash="46bf47de45f52b05654a92f7623f345bdf075c0d" Size="1143346" CompressedSize="196923" RemotePath="2426328-9f23fa6336484e5bb1a248b24d69b967" />
<Pack Hash="4733ca75068a23a29a578352ecc8dddc16d714e6" Size="2097153" CompressedSize="685473" RemotePath="2369826-2acd3c361c9d4a858bd63938a2ab980e" />
<Pack Hash="47c3dd6d524f1923aa08644c2e4083ced4d481a0" Size="2868210" CompressedSize="2868044" RemotePath="2487260-b428468bcd6545bfbb79f02a6605b9ef" />
<Pack Hash="47cb5394541c26f3bab3e60fab36b8acba1d8907" Size="2097157" CompressedSize="615078" RemotePath="2369826-2acd3c361c9d4a858bd63938a2ab980e" />
@@ -32386,7 +32371,6 @@
<Pack Hash="cfdd9050a39e4d7a7e9337cf0bab70cd9347eb55" Size="2054134" CompressedSize="296554" RemotePath="2502955-282171643bd84e4cb54789f6768d4370" />
<Pack Hash="d01535f7276e94b02b13cc27f3966f8867e79101" Size="2096260" CompressedSize="358507" RemotePath="2493588-b79d458e39e94a44804912814d8e1e50" />
<Pack Hash="d04d874a8a5abeb10db060dd59e268c16687663b" Size="2248636" CompressedSize="284895" RemotePath="2369826-2acd3c361c9d4a858bd63938a2ab980e" />
<Pack Hash="d08b402c72c6a474440307971bacfb2663f49033" Size="1835280" CompressedSize="107033" RemotePath="2402503-f5924f63e5f749bb83c8ab9b58a222b1" />
<Pack Hash="d10b44bdbc4c6e17f71468dc40f8432974812f6f" Size="18716936" CompressedSize="6470465" RemotePath="2369826-2acd3c361c9d4a858bd63938a2ab980e" />
<Pack Hash="d111d246a5dff2d0eed94cb2592bfe277ad9e0ea" Size="6498522" CompressedSize="1613053" RemotePath="2369826-2acd3c361c9d4a858bd63938a2ab980e" />
<Pack Hash="d123b08b1aef3c0d2c56bb28885524e1865f0aad" Size="2861636" CompressedSize="532545" RemotePath="2504931-bb9db543bf924632bb34a8ed57a6a659" />
@@ -32396,6 +32380,7 @@
<Pack Hash="d25faf54b177d399192ede835440a8eb4948ab59" Size="2097131" CompressedSize="1161698" RemotePath="2369826-2acd3c361c9d4a858bd63938a2ab980e" />
<Pack Hash="d27c0f6b2f82d4e0112056dc4963a251ad84b3c5" Size="231564" CompressedSize="68022" RemotePath="2482054-e6ea3bde29504ce5b51935e2939eefee" />
<Pack Hash="d324c1434b20b5ef66a2937ab08337f78c5646a0" Size="2096803" CompressedSize="1249054" RemotePath="2487260-b428468bcd6545bfbb79f02a6605b9ef" />
<Pack Hash="d35e0e3be355000f20587f451a57103efbe61016" Size="1810954" CompressedSize="199882" RemotePath="2511091-9a3992ef96b3466aba04a6f9bbe8fb4e" />
<Pack Hash="d367f283ae2fb3697a1861df8a0b81c516669249" Size="2096618" CompressedSize="662978" RemotePath="2493588-b79d458e39e94a44804912814d8e1e50" />
<Pack Hash="d37a91d16b644e50d9f54059d51004d3e2b1af1f" Size="25714888" CompressedSize="6184164" RemotePath="2420600-b68ce30089294bb6a19888db22604724" />
<Pack Hash="d3fa6eb331487a41362af20fc809e610469ecc14" Size="2097054" CompressedSize="615581" RemotePath="2369826-2acd3c361c9d4a858bd63938a2ab980e" />
@@ -32601,6 +32586,7 @@
<Pack Hash="fdf2e4a46547bb61a17d5d84129e99f6ed847fe7" Size="1628992" CompressedSize="257305" RemotePath="2502955-282171643bd84e4cb54789f6768d4370" />
<Pack Hash="fe79883294e7b730b4ea0e6e72c662ced28e999b" Size="2097101" CompressedSize="431945" RemotePath="2500002-69b23dcf7a2d4165b2b432780845acb0" />
<Pack Hash="fe94f39680410922eeef278b013e20b5ee27e7fe" Size="2097142" CompressedSize="1398268" RemotePath="2372940-e2185854aff3439f82782883f74d5bf8" />
<Pack Hash="fe9eb395a4b20285ccad1eeebc882089b33ab889" Size="20689578" CompressedSize="6311176" RemotePath="2511091-9a3992ef96b3466aba04a6f9bbe8fb4e" />
<Pack Hash="fea00c01dd828402354455d324617546eb3d2c8e" Size="2804648" CompressedSize="673075" RemotePath="2502955-282171643bd84e4cb54789f6768d4370" />
<Pack Hash="fecddbf47598e42c13644ce42253e7ca8178eb29" Size="13034661" CompressedSize="13036307" RemotePath="2487260-b428468bcd6545bfbb79f02a6605b9ef" />
<Pack Hash="fef6da9498e0fb8a4591c6b3bdef86850b0cd0e5" Size="21083434" CompressedSize="6379327" RemotePath="2426328-9f23fa6336484e5bb1a248b24d69b967" />

20
Engine/Plugins/Runtime/GearVR/Source/GearVR/Private/GearVR.cpp
View File

@@ -198,7 +198,7 @@ void FGearVR::PoseToOrientationAndPosition(const ovrPosef& InPose, FQuat& OutOri
void FGearVR::GetCurrentOrientationAndPosition(FQuat& CurrentOrientation, FVector& CurrentPosition)
{
const ovrSensorState ss = ovrHmd_GetSensorState(OvrHmd, ovr_GetTimeInSeconds() + MotionPredictionInSeconds, true);
const ovrSensorState ss = ovr_GetPredictedSensorState(OvrMobile, ovr_GetTimeInSeconds() + MotionPredictionInSeconds);
const ovrPosef& pose = ss.Predicted.Pose;
PoseToOrientationAndPosition(pose, CurrentOrientation, CurrentPosition);
@@ -580,7 +580,7 @@ bool FGearVR::Exec( UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar )
}
else if (FParse::Command(&Cmd, TEXT("OVRGLOBALMENU")))
{
ovr_StartPackageActivity(OvrMobile, PUI_CLASS_NAME, PUI_GLOBAL_MENU);
ovr_StartSystemActivity(OvrMobile, PUI_GLOBAL_MENU, NULL);
}
return false;
@@ -760,7 +760,7 @@ void FGearVR::CalculateStereoViewOffset(const EStereoscopicPass StereoPassType,
void FGearVR::ResetOrientationAndPosition(float yaw)
{
const ovrSensorState ss = ovrHmd_GetSensorState(OvrHmd, ovr_GetTimeInSeconds(), true);
const ovrSensorState ss = ovr_GetPredictedSensorState(OvrMobile, ovr_GetTimeInSeconds());
const ovrPosef& pose = ss.Recorded.Pose;
const OVR::Quatf orientation = OVR::Quatf(pose.Orientation);
@@ -996,6 +996,7 @@ void FGearVR::Startup()
UE_LOG(LogHMD, Log, TEXT("GearVR starting with CPU: %d GPU: %d"), CpuLevel, GpuLevel);
FMemory::Memzero(VrModeParms);
VrModeParms.SkipWindowFullscreenReset = true;
VrModeParms.AsynchronousTimeWarp = true;
VrModeParms.DistortionFileName = NULL;
VrModeParms.EnableImageServer = false;
@@ -1255,8 +1256,6 @@ void FGearVR::PreRenderView_RenderThread(FSceneView& View)
if (!RenderParams_RenderThread.ShowFlags.Rendering)
return;
const ovrEyeType eyeIdx = (View.StereoPass == eSSP_LEFT_EYE) ? ovrEye_Left : ovrEye_Right;
FQuat CurrentHmdOrientation = RenderParams_RenderThread.CurHmdOrientation;
FVector CurrentHmdPosition = RenderParams_RenderThread.CurHmdPosition;
@@ -1296,7 +1295,7 @@ void FGearVR::PreRenderViewFamily_RenderThread(FSceneViewFamily& ViewFamily)
{
Lock::Locker lock(&UpdateOnRTLock);
const ovrSensorState ss = ovrHmd_GetSensorState(OvrHmd, ovr_GetTimeInSeconds(), true);
const ovrSensorState ss = ovr_GetPredictedSensorState(OvrMobile, ovr_GetTimeInSeconds());
const ovrPosef& pose = ss.Predicted.Pose;
PoseToOrientationAndPosition(pose, RenderParams_RenderThread.CurHmdOrientation, RenderParams_RenderThread.CurHmdPosition);
@@ -1528,6 +1527,7 @@ void FGearVR::FGearVRBridge::FinishRendering()
glBindTexture(GL_TEXTURE_2D, 0 );
ovr_WarpSwap(Plugin->OvrMobile, &SwapParms);
ovr_HandleDeviceStateChanges(Plugin->OvrMobile);
CurrentSwapChainIndex = (CurrentSwapChainIndex + 1) % 3;
}
}
@@ -1549,6 +1549,8 @@ void FGearVR::FGearVRBridge::Init()
SwapChainTextures[Eye][i] = 0;
}
}
SwapParms = InitTimeWarpParms();
}
void FGearVR::FGearVRBridge::Reset()
@@ -1582,13 +1584,13 @@ void FGearVR::FGearVRBridge::UpdateViewport(const FViewport& Viewport, FRHIViewp
GLuint RTTexId = *(GLuint*)RT->GetNativeResource();
FMatrix ProjMat = Plugin->GetStereoProjectionMatrix(eSSP_LEFT_EYE, 90.0f);
const Matrix4f proj = Plugin->ToMatrix4f(ProjMat);
const ovrMatrix4f proj = Plugin->ToMatrix4f(ProjMat);
// const Matrix4f proj = Matrix4f::PerspectiveRH( FOV, 1.0f, 1.0f, 100.0f);
SwapParms.Images[0][0].TexCoordsFromTanAngles = TanAngleMatrixFromProjection( proj );
SwapParms.Images[0][0].TexCoordsFromTanAngles = TanAngleMatrixFromProjection( &proj );
// SwapParms.Images[0][0].TexId = RTTexId;
// SwapParms.Images[0][0].Pose = Plugin->RenderParams_RenderThread.EyeRenderPose[0];
//
SwapParms.Images[1][0].TexCoordsFromTanAngles = TanAngleMatrixFromProjection( proj );
SwapParms.Images[1][0].TexCoordsFromTanAngles = TanAngleMatrixFromProjection( &proj );
// SwapParms.Images[1][0].TexId = RTTexId;
// SwapParms.Images[1][0].Pose = Plugin->RenderParams_RenderThread.EyeRenderPose[1];

6
Engine/Plugins/Runtime/GearVR/Source/GearVR/Private/GearVR.h
View File

@@ -17,12 +17,13 @@
#include "../Src/Kernel/OVR_Math.h"
#include "../Src/Kernel/OVR_Threads.h"
#include "../Src/OVR_CAPI.h"
#include "../Src/Kernel/OVR_Color.h"
#include "../Src/Kernel/OVR_Timer.h"
#include "OVR.h"
#include "VrApi.h"
#include "VrApi_Helpers.h"
#include "VrApi_Android.h"
#include <GLES2/gl2.h>
@@ -153,7 +154,7 @@ public:
public:
bool bFirstTime;
TimeWarpParms SwapParms;
ovrTimeWarpParms SwapParms;
private:
FGearVR* Plugin;
@@ -417,7 +418,6 @@ private: // data
ovrModeParms VrModeParms;
ovrHmdInfo HmdInfo;
ovrSensorDesc SensorDesc;
FIntPoint EyeViewportSize; // size of the viewport (for one eye). At the moment it is a half of RT.

3
Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile.build.cs vendored
View File

@@ -7,7 +7,7 @@ public class LibOVRMobile : ModuleRules
public LibOVRMobile(TargetInfo Target)
{
// current version of the Mobile Oculus SDK
string LibOVRVersion = "_042";
string LibOVRVersion = "_050";
Type = ModuleType.External;
string OculusThirdPartyDirectory = UEBuildConfiguration.UEThirdPartySourceDirectory + "Oculus/LibOVRMobile/LibOVRMobile" + LibOVRVersion;
@@ -17,7 +17,6 @@ public class LibOVRMobile : ModuleRules
PublicLibraryPaths.Add(OculusThirdPartyDirectory + "/lib/armv7");
PublicAdditionalLibraries.Add("oculus");
PublicAdditionalLibraries.Add("jpeg");
PublicSystemIncludePaths.Add(OculusThirdPartyDirectory + "/VRLib/jni/VrApi");
PublicSystemIncludePaths.Add(OculusThirdPartyDirectory + "/VRLib/jni/LibOVR/Include");

16
Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/generate_build_config.py vendored
View File

@@ -1,16 +0,0 @@
import sys
class_definition = """\
package com.oculusvr.vrlib;
public class BuildConfig {
public final static boolean DEBUG = %(is_debug)s;
}
"""
config = {
'is_debug' : 'true',
}
sys.stdout.write(class_definition % config)

262
Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/jni/3rdParty/stb/stb_image.h vendored
View File

@@ -1,262 +0,0 @@
#ifndef STBI_INCLUDE_STB_IMAGE_H
#define STBI_INCLUDE_STB_IMAGE_H
// Limitations:
// - no jpeg progressive support
// - non-HDR formats support 8-bit samples only (jpeg, png)
// - no delayed line count (jpeg) -- IJG doesn't support either
// - no 1-bit BMP
// - GIF always returns *comp=4
//
// Basic usage (see HDR discussion below):
// int x,y,n;
// unsigned char *data = stbi_load(filename, &x, &y, &n, 0);
// // ... process data if not NULL ...
// // ... x = width, y = height, n = # 8-bit components per pixel ...
// // ... replace '0' with '1'..'4' to force that many components per pixel
// // ... but 'n' will always be the number that it would have been if you said 0
// stbi_image_free(data)
//
// Standard parameters:
// int *x -- outputs image width in pixels
// int *y -- outputs image height in pixels
// int *comp -- outputs # of image components in image file
// int req_comp -- if non-zero, # of image components requested in result
//
// The return value from an image loader is an 'unsigned char *' which points
// to the pixel data. The pixel data consists of *y scanlines of *x pixels,
// with each pixel consisting of N interleaved 8-bit components; the first
// pixel pointed to is top-left-most in the image. There is no padding between
// image scanlines or between pixels, regardless of format. The number of
// components N is 'req_comp' if req_comp is non-zero, or *comp otherwise.
// If req_comp is non-zero, *comp has the number of components that _would_
// have been output otherwise. E.g. if you set req_comp to 4, you will always
// get RGBA output, but you can check *comp to easily see if it's opaque.
//
// An output image with N components has the following components interleaved
// in this order in each pixel:
//
// N=#comp components
// 1 grey
// 2 grey, alpha
// 3 red, green, blue
// 4 red, green, blue, alpha
//
// If image loading fails for any reason, the return value will be NULL,
// and *x, *y, *comp will be unchanged. The function stbi_failure_reason()
// can be queried for an extremely brief, end-user unfriendly explanation
// of why the load failed. Define STBI_NO_FAILURE_STRINGS to avoid
// compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly
// more user-friendly ones.
//
// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized.
//
// ===========================================================================
//
// iPhone PNG support:
//
// By default we convert iphone-formatted PNGs back to RGB; nominally they
// would silently load as BGR, except the existing code should have just
// failed on such iPhone PNGs. But you can disable this conversion by
// by calling stbi_convert_iphone_png_to_rgb(0), in which case
// you will always just get the native iphone "format" through.
//
// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per
// pixel to remove any premultiplied alpha *only* if the image file explicitly
// says there's premultiplied data (currently only happens in iPhone images,
// and only if iPhone convert-to-rgb processing is on).
//
// ===========================================================================
//
// HDR image support (disable by defining STBI_NO_HDR)
//
// stb_image now supports loading HDR images in general, and currently
// the Radiance .HDR file format, although the support is provided
// generically. You can still load any file through the existing interface;
// if you attempt to load an HDR file, it will be automatically remapped to
// LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1;
// both of these constants can be reconfigured through this interface:
//
// stbi_hdr_to_ldr_gamma(2.2f);
// stbi_hdr_to_ldr_scale(1.0f);
//
// (note, do not use _inverse_ constants; stbi_image will invert them
// appropriately).
//
// Additionally, there is a new, parallel interface for loading files as
// (linear) floats to preserve the full dynamic range:
//
// float *data = stbi_loadf(filename, &x, &y, &n, 0);
//
// If you load LDR images through this interface, those images will
// be promoted to floating point values, run through the inverse of
// constants corresponding to the above:
//
// stbi_ldr_to_hdr_scale(1.0f);
// stbi_ldr_to_hdr_gamma(2.2f);
//
// Finally, given a filename (or an open file or memory block--see header
// file for details) containing image data, you can query for the "most
// appropriate" interface to use (that is, whether the image is HDR or
// not), using:
//
// stbi_is_hdr(char *filename);
//
// ===========================================================================
//
// I/O callbacks
//
// I/O callbacks allow you to read from arbitrary sources, like packaged
// files or some other source. Data read from callbacks are processed
// through a small internal buffer (currently 128 bytes) to try to reduce
// overhead.
//
// The three functions you must define are "read" (reads some bytes of data),
// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end).
#ifndef STBI_NO_STDIO
#include <stdio.h>
#endif // STBI_NO_STDIO
#define STBI_VERSION 1
enum
{
STBI_default = 0, // only used for req_comp
STBI_grey = 1,
STBI_grey_alpha = 2,
STBI_rgb = 3,
STBI_rgb_alpha = 4
};
typedef unsigned char stbi_uc;
#ifdef __cplusplus
extern "C" {
#endif
#ifdef STB_IMAGE_STATIC
#define STBIDEF static
#else
#define STBIDEF extern
#endif
//////////////////////////////////////////////////////////////////////////////
//
// PRIMARY API - works on images of any type
//
//
// load image by filename, open file, or memory buffer
//
STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
#ifndef STBI_NO_STDIO
STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *comp, int req_comp);
STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);
// for stbi_load_from_file, file pointer is left pointing immediately after image
#endif
typedef struct
{
int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read
void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative
int (*eof) (void *user); // returns nonzero if we are at end of file/data
} stbi_io_callbacks;
STBIDEF stbi_uc *stbi_load_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp);
#ifndef STBI_NO_HDR
STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp);
#ifndef STBI_NO_STDIO
STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *comp, int req_comp);
STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *comp, int req_comp);
#endif
STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp);
STBIDEF void stbi_hdr_to_ldr_gamma(float gamma);
STBIDEF void stbi_hdr_to_ldr_scale(float scale);
STBIDEF void stbi_ldr_to_hdr_gamma(float gamma);
STBIDEF void stbi_ldr_to_hdr_scale(float scale);
#endif // STBI_NO_HDR
// stbi_is_hdr is always defined
STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user);
STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len);
#ifndef STBI_NO_STDIO
STBIDEF int stbi_is_hdr (char const *filename);
STBIDEF int stbi_is_hdr_from_file(FILE *f);
#endif // STBI_NO_STDIO
// get a VERY brief reason for failure
// NOT THREADSAFE
STBIDEF const char *stbi_failure_reason (void);
// free the loaded image -- this is just free()
STBIDEF void stbi_image_free (void *retval_from_stbi_load);
// get image dimensions & components without fully decoding
STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp);
STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp);
#ifndef STBI_NO_STDIO
STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp);
STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp);
#endif
// for image formats that explicitly notate that they have premultiplied alpha,
// we just return the colors as stored in the file. set this flag to force
// unpremultiplication. results are undefined if the unpremultiply overflow.
STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply);
// indicate whether we should process iphone images back to canonical format,
// or just pass them through "as-is"
STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert);
// ZLIB client - used by PNG, available for other purposes
STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen);
STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header);
STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen);
STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen);
STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen);
// define faster low-level operations (typically SIMD support)
#ifdef STBI_SIMD
typedef void (*stbi_idct_8x8)(stbi_uc *out, int out_stride, short data[64], unsigned short *dequantize);
// compute an integer IDCT on "input"
// input[x] = data[x] * dequantize[x]
// write results to 'out': 64 samples, each run of 8 spaced by 'out_stride'
// CLAMP results to 0..255
typedef void (*stbi_YCbCr_to_RGB_run)(stbi_uc *output, stbi_uc const *y, stbi_uc const *cb, stbi_uc const *cr, int count, int step);
// compute a conversion from YCbCr to RGB
// 'count' pixels
// write pixels to 'output'; each pixel is 'step' bytes (either 3 or 4; if 4, write '255' as 4th), order R,G,B
// y: Y input channel
// cb: Cb input channel; scale/biased to be 0..255
// cr: Cr input channel; scale/biased to be 0..255
STBIDEF void stbi_install_idct(stbi_idct_8x8 func);
STBIDEF void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func);
#endif // STBI_SIMD
#ifdef __cplusplus
}
#endif
#endif // STBI_INCLUDE_STB_IMAGE_H

469
Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/jni/AppRender.cpp vendored
View File

@@ -1,469 +0,0 @@
/************************************************************************************
Filename : AppRender.cpp
Content :
Created :
Authors :
Copyright : Copyright 2014 Oculus VR, LLC. All Rights reserved.
*************************************************************************************/
#include <math.h>
#include <jni.h>
#include <sys/time.h>
#include "GlUtils.h"
#include "GlTexture.h"
#include "VrCommon.h"
#include "App.h"
#include "AppLocal.h"
#include "BitmapFont.h"
#include "Kernel/OVR_TypesafeNumber.h"
#include "GazeCursor.h"
#include "VRMenu/VRMenuMgr.h"
#include "VRMenu/GuiSys.h"
#include "DebugLines.h"
//#define BASIC_FOLLOW 1
namespace OVR
{
const int FPS_NUM_FRAMES_TO_AVERAGE = 30;
// Debug tool to draw outlines of a 3D bounds
void AppLocal::DrawBounds( const Vector3f &mins, const Vector3f &maxs, const Matrix4f &mvp, const Vector3f &color )
{
Matrix4f scaled = mvp * Matrix4f::Translation( mins ) * Matrix4f::Scaling( maxs - mins );
const GlProgram & prog = untexturedMvpProgram;
glUseProgram(prog.program);
glLineWidth( 1.0f );
glUniform4f(prog.uColor, color.x, color.y, color.z, 1);
glUniformMatrix4fv(prog.uMvp, 1, GL_FALSE /* not transposed */,
scaled.Transposed().M[0] );
glBindVertexArrayOES_( unitCubeLines.vertexArrayObject );
glDrawElements(GL_LINES, unitCubeLines.indexCount, GL_UNSIGNED_SHORT, NULL);
glBindVertexArrayOES_( 0 );
}
void AppLocal::DrawDialog( const Matrix4f & mvp )
{
// draw the pop-up dialog
const float now = TimeInSeconds();
if ( now >= dialogStopSeconds )
{
return;
}
const Matrix4f dialogMvp = mvp * dialogMatrix;
const float fadeSeconds = 0.5f;
const float f = now - ( dialogStopSeconds - fadeSeconds );
const float clampF = f < 0.0f ? 0.0f : f;
const float alpha = 1.0f - clampF;
DrawPanel( dialogTexture->textureId, dialogMvp, alpha );
}
// DJB: This function displays the 2D android activities. By showing
// android dialogs within VrActivity, this code is executed.
//
// Test by way of displaying Android activity UI.
void AppLocal::DrawActivity( const Matrix4f & mvp )
{
if ( !activityPanel.Visible )
{
return;
}
#if FANCY_FOLLOW || BASIC_FOLLOW
Matrix4f targetMatrix = lastViewMatrix.Inverted()
* Matrix4f::Translation( 0.0f, -0.0f, -2.5 /* screenDist */ )
* Matrix4f::Scaling( (float)activityPanel.Width / 768.0f,
(float)activityPanel.Height / 768.0f, 1.0f );
#if FANCY_FOLLOW
activityPanel.Matrix = MatrixInterpolation( activityPanel.Matrix, targetMatrix, 0.20 );
#elif BASIC_FOLLOW
activityPanel.Matrix = targetMatrix;
#endif // FANCY or BASIC
#endif // FOLLOW
const Matrix4f dialogMvp = mvp * activityPanel.Matrix;
DrawPanel( activityPanel.Texture->textureId, dialogMvp, 1.0f );
}
void AppLocal::DrawPanel( const GLuint externalTextureId, const Matrix4f & dialogMvp, const float alpha )
{
const GlProgram & prog = externalTextureProgram2;
glUseProgram( prog.program );
glUniform4f(prog.uColor, 1, 1, 1, alpha );
glUniformMatrix4fv(prog.uTexm, 1, GL_FALSE, Matrix4f::Identity().Transposed().M[0]);
glUniformMatrix4fv(prog.uMvp, 1, GL_FALSE, dialogMvp.Transposed().M[0] );
// It is important that panels write to destination alpha, or they
// might get covered by an overlay plane/cube in TimeWarp.
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_EXTERNAL_OES, externalTextureId);
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
panelGeometry.Draw();
glDisable( GL_BLEND );
glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0 ); // don't leave it bound
}
Matrix4f CalculateCameraTimeWarpMatrix( const Quatf &from, const Quatf &to )
{
Matrix4f lastSensorMatrix = Matrix4f( to ).Transposed();
Matrix4f lastViewMatrix = Matrix4f( from ).Transposed();
Matrix4f timeWarp = ( lastSensorMatrix * lastViewMatrix.Inverted() );
return timeWarp;
}
void AppLocal::DrawPassThroughCamera( const float bufferFov, const Quatf &orientation )
{
if ( cameraFovHorizontal == 0 || cameraFovVertical == 0 )
{
return;
}
// const Matrix4f viewMatrix = Matrix4f( orientation ).Transposed();
glDisable( GL_CULL_FACE );
// flipped for portrait mode
const float znear = 0.5f;
const float zfar = 150.0f;
const Matrix4f projectionMatrix = Matrix4f::PerspectiveRH(
DegreeToRad(bufferFov), 1.0f, znear, zfar);
const Matrix4f modelMatrix = Matrix4f(
tan( DegreeToRad( cameraFovHorizontal/2 ) ), 0, 0, 0,
0, tan( DegreeToRad( cameraFovVertical/2 ) ), 0, 0,
0, 0, 0, -1,
0, 0, 0, 1 );
const GlProgram & prog = interpolatedCameraWarp;
glUseProgram( prog.program );
// interpolated time warp to de-waggle the rolling shutter camera image
// enableCameraTimeWarp 0 = none
// enableCameraTimeWarp 1 = full frame
// enableCameraTimeWarp 2 = interpolated
for ( int i = 0 ; i < 2 ; i++ )
{
const Matrix4f timeWarp = enableCameraTimeWarp ?
CalculateCameraTimeWarpMatrix( cameraFramePose[ enableCameraTimeWarp == 2 ? i : 0].Predicted.Pose.Orientation,
orientation )
: Matrix4f::Identity();
const Matrix4f cameraMvp = projectionMatrix * timeWarp * modelMatrix;
glUniformMatrix4fv( i ? prog.uTexm : prog.uMvp, 1, GL_FALSE,
cameraMvp.Transposed().M[0]);
}
glUniform4f(prog.uColor, 1, 1, 1, 1 );
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_EXTERNAL_OES, cameraTexture->textureId);
panelGeometry.Draw();
glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0 ); // don't leave it bound
}
void AppLocal::DrawEyeViewsPostDistorted( Matrix4f const & centerViewMatrix, const int numPresents )
{
const float TEXT_SCALE = 1.0f;
// update vr lib systems after the app frame, but before rendering anything
GetGuiSys().Frame( this, vrFrame, GetVRMenuMgr(), GetDefaultFont(), GetMenuFontSurface() );
GetGazeCursor().Frame( this->lastViewMatrix, vrFrame.DeltaSeconds );
if ( ShowFPS )
{
static double LastFrameTime = TimeInSeconds();
static double AccumulatedFrameInterval = 0.0;
static int NumAccumulatedFrames = 0;
static float LastFrameRate = 60.0f;
double currentFrameTime = TimeInSeconds();
double frameInterval = currentFrameTime - LastFrameTime;
AccumulatedFrameInterval += frameInterval;
NumAccumulatedFrames++;
if ( NumAccumulatedFrames > FPS_NUM_FRAMES_TO_AVERAGE ) {
double interval = ( AccumulatedFrameInterval / NumAccumulatedFrames ); // averaged
AccumulatedFrameInterval = 0.0;
NumAccumulatedFrames = 0;
LastFrameRate = 1.0f / float( interval > 0.000001 ? interval : 0.00001 );
}
fontParms_t fontParms;
fontParms.CenterHoriz = true;
fontParms.Billboard = true;
fontParms.TrackRoll = true;
const Vector3f viewPos( GetViewMatrixPosition( centerViewMatrix ) );
const Vector3f viewFwd( GetViewMatrixForward( centerViewMatrix ) );
const Vector3f textPos( viewPos + viewFwd * 1.5f );
GetWorldFontSurface().DrawTextBillboarded3Df( GetDefaultFont(),
fontParms, textPos, TEXT_SCALE, Vector4f( 1.0f, 0.0f, 0.0f, 1.0f ), "%.1f fps", LastFrameRate );
LastFrameTime = currentFrameTime;
}
if ( InfoTextEndFrame >= vrFrame.FrameNumber )
{
fontParms_t fontParms;
fontParms.CenterHoriz = true;
fontParms.Billboard = true;
fontParms.TrackRoll = true;
const Vector3f viewPos( GetViewMatrixPosition( centerViewMatrix ) );
const Vector3f viewFwd( GetViewMatrixForward( centerViewMatrix ) );
const Vector3f textPos( viewPos + viewFwd * 1.5f );
GetWorldFontSurface().DrawTextBillboarded3Df( GetDefaultFont(),
fontParms, textPos, TEXT_SCALE, Vector4f( 1.0f, 1.0f, 1.0f, 1.0f ), InfoText.ToCStr() );
}
GetMenuFontSurface().Finish( centerViewMatrix );
GetWorldFontSurface().Finish( centerViewMatrix );
GetVRMenuMgr().Finish( centerViewMatrix );
// Increase the fov by about 10 degrees if we are not holding 60 fps so
// there is less black pull-in at the edges.
//
// Doing this dynamically based just on time causes visible flickering at the
// periphery when the fov is increased, so only do it if minimumVsyncs is set.
const float fovDegrees = hmdInfo.SuggestedEyeFov +
( ( ( SwapParms.MinimumVsyncs > 1 ) || ovr_GetPowerLevelStateThrottled() ) ? 10.0f : 0.0f ) +
( ( !showVignette ) ? 5.0f : 0.0f );
// DisplayMonoMode uses a single eye rendering for speed improvement
// and / or high refresh rate double-scan hardware modes.
const int numEyes = renderMonoMode ? 1 : 2;
// Flush out and report any errors
GL_CheckErrors("FrameStart");
if ( drawCalibrationLines && calibrationLinesDrawn )
{
// doing a time warp test, don't generate new images
LOG( "drawCalibrationLines && calibrationLinesDrawn" );
}
else
{
// possibly change the buffer parameters
EyeTargets->BeginFrame( vrParms );
for (int eye = 0; eye < numEyes; eye++)
{
EyeTargets->BeginRenderingEye( eye );
// Call back to the app for drawing.
const Matrix4f mvp = appInterface->DrawEyeView( eye, fovDegrees );
DrawActivity( mvp );
DrawPassThroughCamera( fovDegrees, vrFrame.PoseState.Pose.Orientation );
GetVRMenuMgr().RenderSubmitted( mvp.Transposed() );
GetMenuFontSurface().Render3D( GetDefaultFont(), mvp.Transposed() );
GetWorldFontSurface().Render3D( GetDefaultFont(), mvp.Transposed() );
glDisable( GL_DEPTH_TEST );
glDisable( GL_CULL_FACE );
// Optionally draw thick calibration lines into the texture,
// which will be overlayed by the thinner origin cross when
// distorted to the window.
if ( drawCalibrationLines )
{
EyeDecorations.DrawEyeCalibrationLines(fovDegrees, eye);
calibrationLinesDrawn = true;
}
else
{
calibrationLinesDrawn = false;
}
DrawDialog( mvp );
GetGazeCursor().Render( eye, mvp );
GetDebugLines().Render( mvp.Transposed() );
if ( showVignette )
{
// Draw a thin vignette at the edges of the view so clamping will give black
// This will not be reflected correctly in overlay planes.
// EyeDecorations.DrawEyeVignette();
EyeDecorations.FillEdge( vrParms.resolution, vrParms.resolution );
}
EyeTargets->EndRenderingEye( eye );
}
}
// This eye set is complete, use it now.
if ( numPresents > 0 )
{
const CompletedEyes eyes = EyeTargets->GetCompletedEyes();
for ( int eye = 0 ; eye < TimeWarpParms::MAX_WARP_EYES ; eye++ )
{
SwapParms.Images[eye][0].TexCoordsFromTanAngles = TanAngleMatrixFromFov( fovDegrees );
SwapParms.Images[eye][0].TexId = eyes.Textures[renderMonoMode ? 0 : eye ];
SwapParms.Images[eye][0].Pose = SensorForNextWarp.Predicted;
}
ovr_WarpSwap( OvrMobile, &SwapParms );
}
}
// Draw a screen to an eye buffer the same way it would be drawn as a
// time warp overlay.
void DrawScreenDirect( const GLuint texid, const ovrMatrix4f & mvp )
{
const OVR::Matrix4f mvpMatrix( mvp );
glActiveTexture( GL_TEXTURE0 );
glBindTexture( GL_TEXTURE_2D, texid );
static OVR::GlProgram prog;
if ( !prog.program )
{
prog = OVR::BuildProgram(
"uniform mat4 Mvpm;\n"
"attribute vec4 Position;\n"
"attribute vec2 TexCoord;\n"
"varying highp vec2 oTexCoord;\n"
"void main()\n"
"{\n"
" gl_Position = Mvpm * Position;\n"
" oTexCoord = TexCoord;\n"
"}\n"
,
"uniform sampler2D Texture0;\n"
"varying highp vec2 oTexCoord;\n"
"void main()\n"
"{\n"
" gl_FragColor = texture2D( Texture0, oTexCoord );\n"
"}\n"
);
}
glUseProgram( prog.program );
glUniformMatrix4fv( prog.uMvp, 1, GL_FALSE, mvpMatrix.Transposed().M[0] );
static OVR::GlGeometry unitSquare;
if ( unitSquare.vertexArrayObject == 0 )
{
unitSquare = OVR::BuildTesselatedQuad( 1, 1 );
}
glBindVertexArrayOES_( unitSquare.vertexArrayObject );
glDrawElements( GL_TRIANGLES, unitSquare.indexCount, GL_UNSIGNED_SHORT, NULL );
glBindTexture( GL_TEXTURE_2D, 0 ); // don't leave it bound
}
OVR::GlGeometry BuildFadedScreenMask( const float xFraction, const float yFraction )
{
const float posx[] = { -1.001f, -1.0f + xFraction * 0.25f, -1.0f + xFraction, 1.0f - xFraction, 1.0f - xFraction * 0.25f, 1.001f };
const float posy[] = { -1.001f, -1.0f + yFraction * 0.25f, -1.0f + yFraction, 1.0f - yFraction, 1.0f - yFraction * 0.25f, 1.001f };
const int vertexCount = 6 * 6;
OVR::VertexAttribs attribs;
attribs.position.Resize( vertexCount );
attribs.uv0.Resize( vertexCount );
attribs.color.Resize( vertexCount );
for ( int y = 0; y < 6; y++ )
{
for ( int x = 0; x < 6; x++ )
{
const int index = y * 6 + x;
attribs.position[index].x = posx[x];
attribs.position[index].y = posy[y];
attribs.position[index].z = 0.0f;
attribs.uv0[index].x = 0.0f;
attribs.uv0[index].y = 0.0f;
// the outer edges will have 0 color
const float c = ( y <= 1 || y >= 4 || x <= 1 || x >= 4 ) ? 0.0f : 1.0f;
for ( int i = 0; i < 3; i++ )
{
attribs.color[index][i] = c;
}
attribs.color[index][3] = 1.0f; // solid alpha
}
}
OVR::Array< OVR::TriangleIndex > indices;
indices.Resize( 25 * 6 );
// Should we flip the triangulation on the corners?
int index = 0;
for ( int x = 0; x < 5; x++ )
{
for ( int y = 0; y < 5; y++ )
{
indices[index + 0] = y * 6 + x;
indices[index + 1] = y * 6 + x + 1;
indices[index + 2] = (y + 1) * 6 + x;
indices[index + 3] = (y + 1) * 6 + x;
indices[index + 4] = y * 6 + x + 1;
indices[index + 5] = (y + 1) * 6 + x + 1;
index += 6;
}
}
return OVR::GlGeometry( attribs, indices );
}
// draw a zero to destination alpha
void DrawScreenMask( const ovrMatrix4f & mvp, const float fadeFracX, const float fadeFracY )
{
OVR::Matrix4f mvpMatrix( mvp );
static OVR::GlProgram prog;
if ( !prog.program )
{
prog = OVR::BuildProgram(
"uniform mat4 Mvpm;\n"
"attribute vec4 VertexColor;\n"
"attribute vec4 Position;\n"
"varying lowp vec4 oColor;\n"
"void main()\n"
"{\n"
" gl_Position = Mvpm * Position;\n"
" oColor = vec4( 1.0, 1.0, 1.0, 1.0 - VertexColor.x );\n"
"}\n"
,
"varying lowp vec4 oColor;\n"
"void main()\n"
"{\n"
" gl_FragColor = oColor;\n"
"}\n"
);
}
glUseProgram( prog.program );
glUniformMatrix4fv( prog.uMvp, 1, GL_FALSE, mvpMatrix.Transposed().M[0] );
static OVR::GlGeometry VignetteSquare;
if ( VignetteSquare.vertexArrayObject == 0 )
{
VignetteSquare = BuildFadedScreenMask( fadeFracX, fadeFracY );
}
glColorMask( 0, 0, 0, 1 );
VignetteSquare.Draw();
glColorMask( 1, 1, 1, 1 );
}
} // namespace OVR

801
Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/jni/GlUtils.cpp vendored
View File

File diff suppressed because it is too large Load Diff

26
Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/jni/LibOVR/Include/OVRVersion.h vendored
View File

@@ -1,26 +0,0 @@
/************************************************************************************
Filename : OVRVersion.h
Content :
Copyright : Copyright 2014 Oculus VR, LLC. All Rights reserved.
*************************************************************************************/
#ifndef _OVR_VERSION_H
#define _OVR_VERSION_H
#define STRINGIZE( x ) #x
#define STRINGIZE_VALUE( x ) STRINGIZE( x )
#define OVR_MAJOR_VERSION 0
#define OVR_MINOR_VERSION 4
#define OVR_BUILD_VERSION 2
#define OVR_REV_VERSION 0
#define OVR_VERSION_STRING STRINGIZE_VALUE(OVR_MAJOR_VERSION) \
"." STRINGIZE_VALUE(OVR_MINOR_VERSION) \
"." STRINGIZE_VALUE(OVR_BUILD_VERSION) \
"." STRINGIZE_VALUE(OVR_REV_VERSION) \
" " STRINGIZE_VALUE(__TIMESTAMP__) \
#endif

136
Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/jni/LibOVR/Src/CAPI/CAPI_GlobalState.cpp vendored
View File

@@ -1,136 +0,0 @@
/************************************************************************************
Filename : CAPI_GlobalState.cpp
Content : Maintains global state of the CAPI
Created : January 24, 2014
Authors : Michael Antonov
Copyright : Copyright 2014 Oculus VR, LLC. All Rights reserved.
************************************************************************************/
#include "CAPI_GlobalState.h"
namespace OVR { namespace CAPI {
//-------------------------------------------------------------------------------------
// Open Questions / Notes
// 2. Detect HMDs.
// Challenge: If we do everything through polling, it would imply we want all the devices
// initialized. However, there may be multiple rifts, extra sensors, etc,
// which shouldn't be allocated.
//
// How do you reset orientation Quaternion?
// Can you change IPD?
//-------------------------------------------------------------------------------------
// ***** OVRGlobalState
// Global instance
GlobalState* GlobalState::pInstance = 0;
GlobalState::GlobalState()
{
pManager = *DeviceManager::Create();
pManager->SetMessageHandler(this);
EnumerateDevices();
}
GlobalState::~GlobalState()
{
RemoveHandlerFromDevices();
OVR_ASSERT(HMDs.IsEmpty());
}
int GlobalState::EnumerateDevices()
{
DevicesEnumerated = 0;
DeviceEnumerator<HMDDevice> e = pManager->EnumerateDevices<HMDDevice>();
while (e.IsAvailable())
{
DevicesEnumerated++;
e.Next();
}
return DevicesEnumerated;
}
HMDDevice* GlobalState::CreateDevice(int index)
{
if (index >= DevicesEnumerated)
return 0;
// This isn't quite right since indices aren't guaranteed to match,
// we should cache handles instead... but this should be ok for now.
int i = 0;
DeviceEnumerator<HMDDevice> e = pManager->EnumerateDevices<HMDDevice>();
while (e.IsAvailable())
{
if (i == index)
{
HMDDevice* device = e.CreateDevice();
return device;
}
i++;
e.Next();
}
return 0;
}
void GlobalState::AddHMD(HMDState* hmd)
{
Lock::Locker lock(pManager->GetHandlerLock());
HMDs.PushBack(hmd);
}
void GlobalState::RemoveHMD(HMDState* hmd)
{
Lock::Locker lock(pManager->GetHandlerLock());
hmd->RemoveNode();
}
void GlobalState::NotifyHMDs_AddDevice(DeviceType deviceType)
{
Lock::Locker lock(pManager->GetHandlerLock());
for (HMDState* hmd = HMDs.GetFirst(); !HMDs.IsNull(hmd); hmd = hmd->pNext)
hmd->NotifyAddDevice(deviceType);
}
void GlobalState::OnMessage(const Message& msg)
{
if (msg.Type == Message_DeviceAdded || msg.Type == Message_DeviceRemoved)
{
if (msg.pDevice == pManager)
{
const MessageDeviceStatus& statusMsg =
static_cast<const MessageDeviceStatus&>(msg);
if (msg.Type == Message_DeviceAdded)
{
//LogText("OnMessage DeviceAdded.\n");
// We may have added a sensor/other device; notify any HMDs that might
// need it to check for it later.
NotifyHMDs_AddDevice(statusMsg.Handle.GetType());
}
else
{
//LogText("OnMessage DeviceRemoved.\n");
}
}
}
}
}} // namespace OVR::CAPI

64
Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/jni/LibOVR/Src/CAPI/CAPI_GlobalState.h vendored
View File

@@ -1,64 +0,0 @@
/************************************************************************************
Filename : CAPI_GlobalState.h
Content : Maintains global state of the CAPI
Created : January 24, 2013
Authors : Michael Antonov
Copyright : Copyright 2014 Oculus VR, LLC. All Rights reserved.
************************************************************************************/
#ifndef OVR_CAPI_GlobalState_h
#define OVR_CAPI_GlobalState_h
#include "../OVR_CAPI.h"
#include "CAPI_HMDState.h"
namespace OVR { namespace CAPI {
//-------------------------------------------------------------------------------------
// ***** OVRGlobalState
// Global DeviceManager state - singleton instance of this is created
// by ovr_Initialize().
class GlobalState : public MessageHandler, public NewOverrideBase
{
public:
GlobalState();
~GlobalState();
static GlobalState *pInstance;
int EnumerateDevices();
HMDDevice* CreateDevice(int index);
// MessageHandler implementation
void OnMessage(const Message& msg);
// Helpers used to keep track of HMDs and notify them of sensor changes.
void AddHMD(HMDState* hmd);
void RemoveHMD(HMDState* hmd);
void NotifyHMDs_AddDevice(DeviceType deviceType);
const char* GetLastError()
{
return 0;
}
DeviceManager* GetManager() { return pManager; }
private:
Ptr<DeviceManager> pManager;
int DevicesEnumerated;
// Currently created hmds; protected by Manager lock.
List<HMDState> HMDs;
};
}} // namespace OVR::CAPI
#endif

230
Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/jni/LibOVR/Src/CAPI/CAPI_HMDState.cpp vendored
View File

@@ -1,230 +0,0 @@
/************************************************************************************
Filename : CAPI_HMDState.cpp
Content : State associated with a single HMD
Created : January 24, 2014
Authors : Michael Antonov
Copyright : Copyright 2014 Oculus VR, LLC. All Rights reserved.
************************************************************************************/
#include "CAPI_HMDState.h"
#include "CAPI_GlobalState.h"
namespace OVR { namespace CAPI {
//-------------------------------------------------------------------------------------
// ***** HMDState
HMDState::HMDState(HMDDevice* device)
: pHMD(device), HMDInfoW(device), HMDInfo(HMDInfoW.h),
SensorStarted(0), SensorCaps(0),
AddSensorCount(0), AddLatencyTestCount(0)
{
pLastError = 0;
OVR::CAPI::GlobalState::pInstance->AddHMD(this);
// RenderInfo = GenerateHmdRenderInfoFromHmdInfo ( HMDInfo, NULL );
// SConfig.SetHmdRenderInfo(RenderInfo);
// LastFrameTimeSeconds = 0.0f;
}
HMDState::~HMDState()
{
OVR_ASSERT(OVR::CAPI::GlobalState::pInstance);
StopSensor();
OVR::CAPI::GlobalState::pInstance->RemoveHMD(this);
}
//-------------------------------------------------------------------------------------
// *** Sensor
bool HMDState::StartSensor(unsigned supportedCaps, unsigned requiredCaps)
{
// TBD: Implement an optimized path that allows you to change caps such as yaw.
if (SensorStarted)
StopSensor();
supportedCaps |= requiredCaps;
// TBD: In case of sensor not being immediately available, it would be good to check
// yaw config availability to match it with ovrHmdCap_YawCorrection requirement.
//
if (requiredCaps & ovrHmdCap_Position)
{
pLastError = "ovrHmdCap_Position not supported.";
return false;
}
pSensor = *pHMD->GetSensor();
if (!pSensor)
{
if (requiredCaps & ovrHmdCap_Orientation)
{
pLastError = "Failed to create sensor.";
return false;
}
// Succeed, waiting for sensor become available later.
LogText("StartSensor succeeded - waiting for sensor.\n");
}
else
{
pSensor->SetReportRate(500);
SFusion.AttachToSensor(pSensor);
if (requiredCaps & ovrHmdCap_YawCorrection)
{
if (!SFusion.HasMagCalibration())
{
pLastError = "ovrHmdCap_YawCorrection not available.";
SFusion.AttachToSensor(0);
SFusion.Reset();
pSensor.Clear();
return false;
}
}
SFusion.SetYawCorrectionEnabled((supportedCaps & ovrHmdCap_YawCorrection) != 0);
LogText("Sensor created.\n");
}
AddSensorCount = 0;
SensorStarted = true;
SensorCaps = supportedCaps;
return true;
}
// Stops sensor sampling, shutting down internal resources.
void HMDState::StopSensor()
{
if (SensorStarted)
{
LogText("StopSensor suceeded.\n");
SFusion.AttachToSensor(0);
SFusion.Reset();
pSensor.Clear();
AddSensorCount = 0;
SensorCaps = 0;
SensorStarted = false;
}
}
// Resets sensor orientation.
void HMDState::ResetSensor()
{
SFusion.Reset();
}
// Re-center's on yaw axis only.
void HMDState::RecenterYaw()
{
SFusion.RecenterYaw();
}
// Returns prediction for time.
ovrSensorState HMDState::PredictedSensorState(double absTime, bool allowSensorCreate)
{
SensorState ss;
if (pSensor || (allowSensorCreate && checkCreateSensor()))
{
ss = SFusion.GetPredictionForTime(absTime);
if (allowSensorCreate && !(ss.Status & ovrStatus_OrientationTracked))
{
// Not needed yet; SFusion.AttachToSensor(0);
// This seems to reset orientation anyway...
pSensor.Clear();
}
}
else
{
// SensorState() defaults to 0s.
// ss.Pose.Orientation = Quatf();
// ..
// We still want valid times so frames will get a delta-time
// and allow operation with a joypad when the sensor isn't
// connected.
ss.Recorded.TimeInSeconds = absTime;
ss.Predicted.TimeInSeconds = absTime;
}
ss.Status |= ovrStatus_HmdConnected;
return ss;
}
bool HMDState::checkCreateSensor()
{
if (SensorStarted && !pSensor && AddSensorCount)
{
AddSensorCount = 0;
pSensor = *pHMD->GetSensor();
if (pSensor)
{
pSensor->SetReportRate(500);
SFusion.AttachToSensor(pSensor);
SFusion.SetYawCorrectionEnabled((SensorCaps & ovrHmdCap_YawCorrection) != 0);
LogText("Sensor created.\n");
return true;
}
}
return false;
}
bool HMDState::ProcessLatencyTest(unsigned char rgbColorOut[3])
{
bool result = false;
// Check create.
if (pLatencyTester)
{
if (pLatencyTester->IsConnected())
{
Color colorToDisplay;
LatencyUtil.ProcessInputs();
result = LatencyUtil.DisplayScreenColor(colorToDisplay);
rgbColorOut[0] = colorToDisplay.R;
rgbColorOut[1] = colorToDisplay.G;
rgbColorOut[2] = colorToDisplay.B;
}
else
{
// Disconnect.
LatencyUtil.SetDevice(0);
pLatencyTester = 0;
LogText("LATENCY SENSOR disconnected.\n");
}
}
else if (AddLatencyTestCount)
{
// This might have some unlikely race condition issue which could cause us to miss a device...
AddLatencyTestCount = 0;
pLatencyTester = *OVR::CAPI::GlobalState::pInstance->GetManager()->EnumerateDevices<LatencyTestDevice>().CreateDevice();
if (pLatencyTester)
{
LatencyUtil.SetDevice(pLatencyTester);
LogText("LATENCY TESTER connected\n");
}
}
return result;
}
}} // namespace OVR::CAPI

105
Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/jni/LibOVR/Src/CAPI/CAPI_HMDState.h vendored
View File

@@ -1,105 +0,0 @@
/************************************************************************************
Filename : CAPI_HMDState.h
Content : State associated with a single HMD
Created : January 24, 2014
Authors : Michael Antonov
Copyright : Copyright 2014 Oculus VR, LLC. All Rights reserved.
************************************************************************************/
#ifndef OVR_CAPI_HMDState_h
#define OVR_CAPI_HMDState_h
#include "../Kernel/OVR_Math.h"
#include "../Kernel/OVR_List.h"
#include "../Kernel/OVR_Log.h"
#include "../OVR_CAPI.h"
#include "../OVR_SensorFusion.h"
#include "../Util/Util_LatencyTest.h"
struct ovrHmdStruct { };
namespace OVR { namespace CAPI {
//-------------------------------------------------------------------------------------
// ***** HMDState
// Describes a single HMD.
class HMDState : public ListNode<HMDState>,
public ovrHmdStruct, public NewOverrideBase
{
public:
HMDState(HMDDevice* device);
virtual ~HMDState();
// Delegated access APIs
// ovrHmdDesc GetDesc();
bool StartSensor(unsigned supportedCaps, unsigned requiredCaps);
void StopSensor();
void ResetSensor();
void RecenterYaw();
ovrSensorState PredictedSensorState(double absTime, bool allowSensorCreate);
bool ProcessLatencyTest(unsigned char rgbColorOut[3]);
const char* GetLastError()
{
const char* p = pLastError;
pLastError = 0;
return p;
}
void NotifyAddDevice(DeviceType deviceType)
{
if (deviceType == Device_Sensor)
AddSensorCount++;
else if (deviceType == Device_LatencyTester)
{
AddLatencyTestCount++;
}
}
bool checkCreateSensor();
Ptr<HMDDevice> pHMD;
// Wrapper to support 'const'
struct HMDInfoWrapper
{
HMDInfoWrapper(HMDDevice* device) { if (device) device->GetDeviceInfo(&h); }
OVR::HMDInfo h;
};
// HMDInfo shouldn't change, as its string pointers are passed out.
const HMDInfoWrapper HMDInfoW;
const OVR::HMDInfo& HMDInfo;
// Whether we called StartSensor() and requested sensor caps.
// pSensor may still be null or non-running after start if it wasn't yet available
bool SensorStarted;
unsigned SensorCaps;
// Atomic integer used as a flag that we should check the device.
AtomicInt<int> AddSensorCount;
Ptr<SensorDevice> pSensor; // Head
SensorFusion SFusion;
// Latency tester
Ptr<LatencyTestDevice> pLatencyTester;
Util::LatencyTest LatencyUtil;
AtomicInt<int> AddLatencyTestCount;
const char* pLastError;
};
}} // namespace OVR::CAPI
#endif // OVR_CAPI_HMDState_h

257
Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/jni/LibOVR/Src/OVR_CAPI.cpp vendored
View File

@@ -1,257 +0,0 @@
/************************************************************************************
Filename : OVR_CAPI.cpp
Content : Experimental simple C interface to the HMD - version 1.
Created : November 30, 2013
Authors : Michael Antonov
Copyright : Copyright 2014 Oculus VR, LLC. All Rights reserved.
************************************************************************************/
#include "OVR_CAPI.h"
#include "../Include/OVR.h"
#include "Kernel/OVR_Timer.h"
#include "OVR_PhoneSensors.h"
#include "CAPI/CAPI_GlobalState.h"
#include "CAPI/CAPI_HMDState.h"
//-------------------------------------------------------------------------------------
namespace OVR {
// ***** SensorState
SensorState::SensorState(const ovrSensorState& s)
{
*this = reinterpret_cast<const SensorState&>(s);
}
SensorState::operator const ovrSensorState& () const
{
OVR_COMPILER_ASSERT(sizeof(SensorState) == sizeof(ovrSensorState));
return reinterpret_cast<const ovrSensorState&>(*this);
}
} // namespace OVR
//-------------------------------------------------------------------------------------
double ovr_GetTimeInSeconds()
{
return OVR::Timer::GetSeconds();
}
//-------------------------------------------------------------------------------------
// 1. Init/shutdown.
bool ovr_Initialize()
{
using namespace OVR;
using namespace OVR::CAPI;
if (GlobalState::pInstance)
return true;
// We must set up the system for the plugin to work
if (!OVR::System::IsInitialized())
OVR::System::Init(OVR::Log::ConfigureDefaultLog(OVR::LogMask_All));
// Constructor detects devices
GlobalState::pInstance = new GlobalState;
return true;
}
void ovr_Shutdown()
{
using namespace OVR;
using namespace OVR::CAPI;
if (!GlobalState::pInstance)
return;
delete GlobalState::pInstance;
GlobalState::pInstance = 0;
// We should clean up the system to be complete
OVR::System::Destroy();
}
int ovrHmd_Detect()
{
using namespace OVR;
using namespace OVR::CAPI;
if (!GlobalState::pInstance)
return 0;
return GlobalState::pInstance->EnumerateDevices();
}
ovrHmd ovrHmd_Create(int index)
{
using namespace OVR;
using namespace OVR::CAPI;
if (!GlobalState::pInstance)
return 0;
Ptr<HMDDevice> device = *GlobalState::pInstance->CreateDevice(index);
if (!device)
return 0;
HMDState* hmds = new HMDState(device);
if (!hmds)
return 0;
// if (desc)
// ovrHmd_GetDesc(hmds, desc);
return hmds;
}
void ovrHmd_Destroy(ovrHmd hmd)
{
if (!hmd)
return;
// TBD: Any extra shutdown?
delete (OVR::CAPI::HMDState*)hmd;
}
const char* ovrHmd_GetLastError(ovrHmd hmd)
{
using namespace OVR;
using namespace OVR::CAPI;
if (!hmd)
{
if (!GlobalState::pInstance)
return "LibOVR not initialized.";
return GlobalState::pInstance->GetLastError();
}
HMDState* p = (HMDState*)hmd;
return p->GetLastError();
}
//-------------------------------------------------------------------------------------
// *** Sensor
bool ovrHmd_StartSensor(ovrHmd hmd, unsigned supportedCaps, unsigned requiredCaps)
{
OVR::CAPI::HMDState* p = (OVR::CAPI::HMDState*)hmd;
// TBD: Decide if we null-check arguments.
return p->StartSensor(supportedCaps, requiredCaps);
}
void ovrHmd_StopSensor(ovrHmd hmd)
{
OVR::CAPI::HMDState* p = (OVR::CAPI::HMDState*)hmd;
p->StopSensor();
}
void ovrHmd_ResetSensor(ovrHmd hmd)
{
OVR::CAPI::HMDState* p = (OVR::CAPI::HMDState*)hmd;
p->ResetSensor();
}
void ovrHmd_RecenterYaw(ovrHmd hmd)
{
OVR::CAPI::HMDState* p = (OVR::CAPI::HMDState*)hmd;
p->RecenterYaw();
}
ovrSensorState ovrHmd_GetSensorState(ovrHmd hmd, double absTime, bool allowSensorCreate)
{
OVR::CAPI::HMDState* p = (OVR::CAPI::HMDState*)hmd;
return p->PredictedSensorState(absTime, allowSensorCreate );
}
// Returns information about a sensor.
// Only valid after SensorStart.
bool ovrHmd_GetSensorDesc(ovrHmd hmd, ovrSensorDesc* descOut)
{
OVR::CAPI::HMDState* p = (OVR::CAPI::HMDState*)hmd;
if (p->pSensor)
{
OVR::SensorInfo si;
p->pSensor->GetDeviceInfo(&si);
descOut->VendorId = si.VendorId;
descOut->ProductId = si.ProductId;
OVR_COMPILER_ASSERT(sizeof(si.SerialNumber) == sizeof(descOut->SerialNumber));
memcpy(descOut->SerialNumber, si.SerialNumber, sizeof(si.SerialNumber) );
// JDC: needed to disambiguate Samsung headsets
descOut->Version = si.Version;
return true;
}
return false;
}
//-------------------------------------------------------------------------------------
// ***** Latency Test interface
bool ovrHmd_ProcessLatencyTest(ovrHmd hmd, unsigned char rgbColorOut[3])
{
OVR::CAPI::HMDState* p = (OVR::CAPI::HMDState*)hmd;
return p->ProcessLatencyTest(rgbColorOut);
}
const char* ovrHmd_GetLatencyTestResult(ovrHmd hmd)
{
OVR::CAPI::HMDState* p = (OVR::CAPI::HMDState*)hmd;
return p->LatencyUtil.GetResultsString();
}
//-------------------------------------------------------------------------------------
// ****** Special access for VRConfig
// Return the sensor fusion object for the purposes of magnetometer calibration. The
// function is private and is only exposed through VRConfig header declarations
OVR::SensorFusion* ovrHmd_GetSensorFusion(ovrHmd hmd)
{
OVR::CAPI::HMDState* p = (OVR::CAPI::HMDState*)hmd;
return &p->SFusion;
}
// -----------------------------------------------------------------------------------
// ***** Mobile Additions
#include "OVR_DeviceImpl.h"
int ovr_GetDeviceManagerThreadTid()
{
using namespace OVR;
using namespace OVR::CAPI;
if (!GlobalState::pInstance)
return 0;
return static_cast<DeviceManagerImpl*>(GlobalState::pInstance->GetManager())->GetThreadTid();
}
void ovr_SuspendDeviceManagerThread()
{
using namespace OVR;
using namespace OVR::CAPI;
if (!GlobalState::pInstance)
return;
static_cast<DeviceManagerImpl*>(GlobalState::pInstance->GetManager())->SuspendThread();
}
void ovr_ResumeDeviceManagerThread()
{
using namespace OVR;
using namespace OVR::CAPI;
if (!GlobalState::pInstance)
return;
static_cast<DeviceManagerImpl*>(GlobalState::pInstance->GetManager())->ResumeThread();
}

264
Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/jni/LibOVR/Src/OVR_CAPI.h vendored
View File

@@ -1,264 +0,0 @@
/************************************************************************************
Filename : OVR_CAPI.h
Content : C Interface to Oculus sensors and rendering.
Created : November 23, 2013
Authors : Michael Antonov
Copyright : Copyright 2014 Oculus VR, LLC. All Rights reserved.
************************************************************************************/
#ifndef OVR_CAPI_h
#define OVR_CAPI_h
//-----------------------------------------------------------------------------------
// ***** Simple Math Structures
// 2D integer
typedef struct ovrVector2i_
{
int x, y;
} ovrVector2i;
typedef struct ovrSizei_
{
int w, h;
} ovrSizei;
typedef struct ovrRecti_
{
ovrVector2i Pos;
ovrSizei Size;
} ovrRecti;
// 3D
typedef struct ovrQuatf_
{
float x, y, z, w;
} ovrQuatf;
typedef struct ovrVector2f_
{
float x, y;
} ovrVector2f;
typedef struct ovrVector3f_
{
float x, y, z;
} ovrVector3f;
typedef struct ovrMatrix4f_
{
float M[4][4];
} ovrMatrix4f;
// Position and orientation together.
typedef struct ovrPosef_
{
ovrQuatf Orientation;
ovrVector3f Position;
} ovrPosef;
// Full pose (rigid body) configuration with first and second derivatives.
typedef struct ovrPoseStatef_
{
ovrPosef Pose;
ovrVector3f AngularVelocity;
ovrVector3f LinearVelocity;
ovrVector3f AngularAcceleration;
ovrVector3f LinearAcceleration;
double TimeInSeconds; // Absolute time of this state sample.
} ovrPoseStatef;
/*
// Field Of View (FOV) in tangent of the angle units.
// As an example, for a standard 90 degree vertical FOV, we would
// have: { UpTan = tan(90 degrees / 2), DownTan = tan(90 degrees / 2) }.
typedef struct ovrFovPort_
{
float UpTan;
float DownTan;
float LeftTan;
float RightTan;
} ovrFovPort;
*/
//-----------------------------------------------------------------------------------
// ***** HMD Types
// HMD capability bits reported by device.
//
typedef enum
{
//ovrHmdCap_Present = 0x0001, // This HMD exists (as opposed to being unplugged).
//ovrHmdCap_Available = 0x0002, // HMD and is sensor is available for use
// (if not owned by another app).
ovrHmdCap_Orientation = 0x0010, // Support orientation tracking (IMU).
ovrHmdCap_YawCorrection = 0x0020, // Supports yaw correction through magnetometer or other means.
ovrHmdCap_Position = 0x0040, // Supports positional tracking.
} ovrHmdCapBits;
// Handle to HMD; returned by ovrHmd_Create.
typedef struct ovrHmdStruct* ovrHmd;
/*
// Describes the type of positional tracking being done.
typedef enum
{
ovrPose_None,
ovrPose_HeadModel,
ovrPose_Positional
} ovrPoseType;
*/
// Bit flags describing the current status of sensor tracking.
typedef enum
{
ovrStatus_OrientationTracked = 0x0001, // Orientation is currently tracked (connected and in use).
ovrStatus_PositionTracked = 0x0002, // Position is currently tracked (FALSE if out of range).
ovrStatus_PositionConnected = 0x0020, // Position tracking HW is connected.
ovrStatus_HmdConnected = 0x0080 // HMD Display is available & connected.
} ovrStatusBits;
// Specifies which eye is being used for rendering.
// This type explicitly does not include a third "NoStereo" option, as such is
// not required for an HMD-centered API.
typedef enum
{
ovrEye_Left = 0,
ovrEye_Right = 1,
ovrEye_Count = 2
} ovrEyeType;
// State of the sensor at a given absolute time.
typedef struct ovrSensorState_
{
// Predicted pose configuration at requested absolute time.
// One can determine the time difference between predicted and actual
// readings by comparing ovrPoseState.TimeInSeconds.
ovrPoseStatef Predicted;
// Actual recorded pose configuration based on the sensor sample at a
// moment closest to the requested time.
ovrPoseStatef Recorded;
// Sensor temperature reading, in degrees Celsius, as sample time.
float Temperature;
// Sensor status described by ovrStatusBits.
unsigned Status;
} ovrSensorState;
// For now.
// TBD: Decide if this becomes a part of HMDDesc
typedef struct ovrSensorDesc_
{
// HID Vendor and ProductId of the device.
short VendorId;
short ProductId;
// Sensor (and display) serial number.
char SerialNumber[20];
// From DeviceInfo
unsigned Version;
} ovrSensorDesc;
// -----------------------------------------------------------------------------------
// ***** API Interfaces
// Basic steps to use the API:
//
// Setup:
// 1. ovr_Initialize();
// 2. ovrHmd hmd = ovrHmd_Create(0);
// 3. ovrHmd_StartSensor(hmd, ovrHmdCap_Orientation|ovrHmdCap_YawCorrection, 0);
//
// Game Loop:
// 6. Call ovrHmd_PredictedSensorState for get rendering orientation for each eye.
//
// Shutdown:
// 9. ovrHmd_Destroy(hmd)
// 10. ovr_Shutdown()
//
// Library init/shutdown, must be called around all other OVR code.
// No other functions calls are allowed before ovr_Initialize succeeds or after ovr_Shutdown.
bool ovr_Initialize();
void ovr_Shutdown();
// Detects or re-detects HMDs and reports the total number detected.
// Users can get information about each HMD by calling ovrHmd_Create with an index.
int ovrHmd_Detect();
// Creates a handle to an HMD and optionally fills in data about it.
// Index can [0 .. ovrHmd_Detect()-1]; index mappings can cange after each ovrHmd_Detect call.
// If not null, returned handle must be freed with ovrHmd_Destroy.
ovrHmd ovrHmd_Create(int index);
void ovrHmd_Destroy(ovrHmd hmd);
// Returns last error for HMD state. Returns null for no error.
// String is valid until next call or GetLastError or HMD is destroyed.
// Pass null hmd to get global error (for create, etc).
const char* ovrHmd_GetLastError(ovrHmd hmd);
//-------------------------------------------------------------------------------------
// ***** Sensor Interface
// Starts sensor sampling, enabling specified capabilities, described by ovrHmdCapBits.
// - supportedCaps specifies support that is requested. The function will succeed even if,
// if these caps are not available (i.e. sensor or camera is unplugged). Support will
// automatically be enabled if such device is plugged in later. Software should check
// ovrSensorState.Status for real-time status.
// - requiredCaps specify sensor capabilities required at the time of the call. If they
// are not available, the function will fail. Pass 0 if only specifying SupportedCaps.
bool ovrHmd_StartSensor(ovrHmd hmd, unsigned supportedSensorCaps,
unsigned requiredSensorCaps);
// Stops sensor sampling, shutting down internal resources.
void ovrHmd_StopSensor(ovrHmd hmd);
// Resets sensor orientation.
void ovrHmd_ResetSensor(ovrHmd hmd);
// Recenters the orientation on the yaw axis.
void ovrHmd_RecenterYaw(ovrHmd hmd);
// Returns sensor state reading based on the specified absolute system time.
// Pass absTime value of 0.0 to request the most recent sensor reading; in this case
// both PredictedPose and SamplePose will have the same value.
// ovrHmd_GetEyePredictedSensorState relies on this internally.
// This may also be used for more refined timing of FrontBuffer rendering logic, etc.
ovrSensorState ovrHmd_GetSensorState(ovrHmd hmd, double absTime, bool allowSensorCreate);
// Returns information about a sensor.
// Only valid after SensorStart.
bool ovrHmd_GetSensorDesc(ovrHmd hmd, ovrSensorDesc* descOut);
//-------------------------------------------------------------------------------------
// ***** Stateless math setup functions
// Returns global, absolute high-resolution time in seconds. This is the same
// value as used in sensor messages.
double ovr_GetTimeInSeconds();
// -----------------------------------------------------------------------------------
// ***** Latency Test interface
// Does latency test processing and returns 'TRUE' if specified rgb color should
// be used to clear the screen.
bool ovrHmd_ProcessLatencyTest(ovrHmd hmd, unsigned char rgbColorOut[3]);
// Returns non-null string once with latency test result, when it is available.
// Buffer is valid until next call.
const char* ovrHmd_GetLatencyTestResult(ovrHmd hmd);
// -----------------------------------------------------------------------------------
// ***** Mobile Additions
int ovr_GetDeviceManagerThreadTid();
void ovr_SuspendDeviceManagerThread();
void ovr_ResumeDeviceManagerThread();
#endif // OVR_CAPI_h

732
Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/jni/PlatformActivity.cpp vendored
View File

File diff suppressed because it is too large Load Diff

100
Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/jni/RayTracer/RtIntersect.cpp vendored
View File

@@ -1,100 +0,0 @@
/************************************************************************************
Filename : RtIntersect.cpp
Content : Basic intersection routines.
Created : May, 2014
Authors : J.M.P. van Waveren
Copyright : Copyright 2014 Oculus VR, LLC. All Rights reserved.
*************************************************************************************/
#include "RtIntersect.h"
#include <math.h>
#include "Kernel/OVR_Math.h"
#include "Kernel/OVR_Alg.h"
using namespace OVR;
bool RtIntersect::RayBounds( const Vector3f & rayStart, const Vector3f & rayDir,
const Vector3f & mins, const Vector3f & maxs,
float & t0, float & t1 )
{
const float rcpDirX = ( fabsf( rayDir.x ) > Math<float>::SmallestNonDenormal ) ? ( 1.0f / rayDir.x ) : Math<float>::HugeNumber;
const float rcpDirY = ( fabsf( rayDir.y ) > Math<float>::SmallestNonDenormal ) ? ( 1.0f / rayDir.y ) : Math<float>::HugeNumber;
const float rcpDirZ = ( fabsf( rayDir.z ) > Math<float>::SmallestNonDenormal ) ? ( 1.0f / rayDir.z ) : Math<float>::HugeNumber;
const float sX = ( mins.x - rayStart.x ) * rcpDirX;
const float sY = ( mins.y - rayStart.y ) * rcpDirY;
const float sZ = ( mins.z - rayStart.z ) * rcpDirZ;
const float tX = ( maxs.x - rayStart.x ) * rcpDirX;
const float tY = ( maxs.y - rayStart.y ) * rcpDirY;
const float tZ = ( maxs.z - rayStart.z ) * rcpDirZ;
const float minX = Alg::Min( sX, tX );
const float minY = Alg::Min( sY, tY );
const float minZ = Alg::Min( sZ, tZ );
const float maxX = Alg::Max( sX, tX );
const float maxY = Alg::Max( sY, tY );
const float maxZ = Alg::Max( sZ, tZ );
t0 = Alg::Max( minX, Alg::Max( minY, minZ ) );
t1 = Alg::Min( maxX, Alg::Min( maxY, maxZ ) );
return ( t0 <= t1 );
}
bool RtIntersect::RayTriangle( const Vector3f & rayStart, const Vector3f & rayDir,
const Vector3f & v0, const Vector3f & v1, const Vector3f & v2,
float & t0, float & u, float & v )
{
assert( rayDir.IsNormalized() );
const Vector3f edge1 = v1 - v0;
const Vector3f edge2 = v2 - v0;
const Vector3f tv = rayStart - v0;
const Vector3f pv = rayDir.Cross( edge2 );
const Vector3f qv = tv.Cross( edge1 );
const float det = edge1.Dot( pv );
// If the determinant is negative then the triangle is backfacing.
if ( det <= 0.0f )
{
return false;
}
// This code has been modified to only perform a floating-point
// division if the ray actually hits the triangle. If back facing
// triangles are not culled then the sign of 's' and 't' need to
// be flipped. This can be accomplished by multiplying the values
// with the determinant instead of the reciprocal determinant.
const float s = tv.Dot( pv );
const float t = rayDir.Dot( qv );
if ( s >= 0.0f && s <= det )
{
if ( t >= 0.0f && s + t <= det )
{
// If the determinant is almost zero then the ray lies in the triangle plane.
// This comparison is done last because it is usually rare for
// the ray to lay in the triangle plane.
if ( fabsf( det ) > Math<float>::SmallestNonDenormal )
{
const float rcpDet = 1.0f / det;
t0 = edge2.Dot( qv ) * rcpDet;
u = s * rcpDet;
v = t * rcpDet;
return true;
}
}
}
return false;
}

49
Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/jni/RayTracer/RtIntersect.h vendored
View File

@@ -1,49 +0,0 @@
/************************************************************************************
Filename : RtIntersect.h
Content : Basic intersection routines.
Created : May, 2014
Authors : J.M.P. van Waveren
Copyright : Copyright 2014 Oculus VR, LLC. All Rights reserved.
*************************************************************************************/
#ifndef __RTINTERSECT_H__
#define __RTINTERSECT_H__
#include "Kernel/OVR_Math.h"
namespace RtIntersect
{
/*
An Efficient and Robust Ray–Box Intersection Algorithm
Amy Williams, Steve Barrus, R. Keith Morley, Peter Shirley
Journal of Graphics Tools, Issue 10, Pages 49-54, June 2005
Returns true if the ray intersects the bounds.
't0' and 't1' are the distances along the ray where the intersections occurs.
1st intersection = rayStart + t0 * rayDir
2nd intersection = rayStart + t1 * rayDir
*/
bool RayBounds( const OVR::Vector3f & rayStart, const OVR::Vector3f & rayDir,
const OVR::Vector3f & mins, const OVR::Vector3f & maxs,
float & t0, float & t1 );
/*
Fast, Minimum Storage Ray/Triangle Intersection
Tomas Möller, Ben Trumbore
Journal of Graphics Tools, 1997
Triangles are back-face culled.
Returns true if the ray intersects the triangle.
't0' is the distance along the ray where the intersection occurs.
intersection = rayStart + t0 * rayDir;
'u' and 'v' are the barycentric coordinates.
intersection = ( 1 - u - v ) * v0 + u * v1 + v * v2
*/
bool RayTriangle( const OVR::Vector3f & rayStart, const OVR::Vector3f & rayDir,
const OVR::Vector3f & v0, const OVR::Vector3f & v1, const OVR::Vector3f & v2,
float & t0, float & u, float & v );
}
#endif // !__RTINTERSECT_H__

78
Engine/Source/ThirdParty/Oculus/LibOVRMobile/LibOVRMobile_042/VRLib/jni/RayTracer/RtTrace.h vendored
View File

@@ -1,78 +0,0 @@
/************************************************************************************
Filename : RtTrace.h
Content : Ray tracer using a KD-Tree.
Created : May, 2014
Authors : J.M.P. van Waveren
Copyright : Copyright 2014 Oculus VR, LLC. All Rights reserved.
*************************************************************************************/
#ifndef __RTTRACE_H__
#define __RTTRACE_H__
#include "../LibOVR/Src/Kernel/OVR_Math.h"
#include "../LibOVR/Src/Kernel/OVR_Array.h"
namespace OVR
{
const int RT_KDTREE_MAX_LEAF_TRIANGLES = 4;
struct kdtree_header_t
{
int numVertices;
int numUvs;
int numIndices;
int numNodes;
int numLeafs;
int numOverflow;
Bounds3f bounds;
};
struct kdtree_node_t
{
// bits [ 0,0] = leaf flag
// bits [ 2,1] = split plane (0 = x, 1 = y, 2 = z, 3 = invalid)
// bits [31,3] = index of left child (+1 = right child index), or index of leaf data
unsigned int data;
float dist;
};
struct kdtree_leaf_t
{
int triangles[RT_KDTREE_MAX_LEAF_TRIANGLES];
int ropes[6];
Bounds3f bounds;
};
struct traceResult_t
{
int triangleIndex;
float fraction;
Vector2f uv;
Vector3f normal;
};
class RtTrace
{
public:
RtTrace() {}
~RtTrace() {}
traceResult_t Trace( const Vector3f & start, const Vector3f & end ) const;
traceResult_t Trace_Exhaustive( const Vector3f & start, const Vector3f & end ) const;
public:
kdtree_header_t header;
Array< Vector3f > vertices;
Array< Vector2f > uvs;
Array< int > indices;
Array< kdtree_node_t > nodes;
Array< kdtree_leaf_t > leafs;
Array< int > overflow;
};
} // namespace OVR
#endif // !__RTTRACE_H__

Some files were not shown because too many files have changed in this diff Show More